diff options
Diffstat (limited to 'node_modules/@jet-app/app-store/tmp/src/common/editorial-pages')
40 files changed, 3868 insertions, 0 deletions
diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-action-util.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-action-util.js new file mode 100644 index 0000000..9c50926 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-action-util.js @@ -0,0 +1,58 @@ +import * as lockups from "../lockups/lockups"; +import { CollectionShelfDisplayStyle } from "./editorial-page-types"; +/** + * For a given piece of MAPI data create the primary clickAction for the component with this data + * @param objectGraph + * @param data + * @param shelfToken + */ +export function createPrimaryActionForComponentFromData(objectGraph, data, shelfToken, baseClickOptions) { + const clickOptions = createClickOptionsFromData(objectGraph, data, shelfToken, baseClickOptions); + const primaryAction = lockups.actionFromData(objectGraph, data, clickOptions, shelfToken.clientIdentifierOverride); + return primaryAction; +} +function createClickOptionsFromData(objectGraph, data, shelfToken, baseClickOptions) { + const targetType = clickTargetForCollectionDisplayStyle(objectGraph, shelfToken.collectionDisplayStyle); + const clickOptions = { + ...shelfToken.metricsImpressionOptions, + ...baseClickOptions, + id: data.id, + targetType: targetType, + }; + return clickOptions; +} +export function clickTargetForCollectionDisplayStyle(objectGraph, displayStyle) { + switch (displayStyle) { + case CollectionShelfDisplayStyle.Hero: + return "hero"; + case CollectionShelfDisplayStyle.TextOnly: + return "textOnly"; + case CollectionShelfDisplayStyle.TextWithArtwork: + return "textWithArtwork"; + case CollectionShelfDisplayStyle.BrickSmall: + return "brickSmall"; + case CollectionShelfDisplayStyle.BrickMedium: + return "brickMedium"; + case CollectionShelfDisplayStyle.BrickLarge: + return "brickLarge"; + case CollectionShelfDisplayStyle.EditorialLockupMedium: + case CollectionShelfDisplayStyle.EditorialLockupMediumVariant: + return "editorialLockupMedium"; + case CollectionShelfDisplayStyle.EditorialLockupLarge: + case CollectionShelfDisplayStyle.EditorialLockupLargeVariant: + return "editorialLockupLarge"; + case CollectionShelfDisplayStyle.LockupSmall: + return "lockupSmall"; + case CollectionShelfDisplayStyle.LockupLarge: + return "lockupLarge"; + case CollectionShelfDisplayStyle.StorySmall: + return "storySmall"; + case CollectionShelfDisplayStyle.StoryMedium: + return "storyMedium"; + case CollectionShelfDisplayStyle.BreakoutLarge: + return "largeBreakout"; + default: + return "lockup"; + } +} +//# sourceMappingURL=editorial-action-util.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-data-util.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-data-util.js new file mode 100644 index 0000000..041bde4 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-data-util.js @@ -0,0 +1,173 @@ +import * as serverData from "../../foundation/json-parsing/server-data"; +import * as mediaAttributes from "../../foundation/media/attributes"; +import * as mediaRelationship from "../../foundation/media/relationships"; +import * as content from "../content/content"; +import { EditorialShelfType } from "./editorial-page-types"; +/** + * Take the remaining content fromt he shelfToken if this is not the first render, otherwise + * use the initial data. + * + * @param objectGraph + * @param shelfToken + */ +export function extractRemainingItemsOrInitialShelfContents(objectGraph, shelfToken) { + if (!shelfToken.isFirstRender) { + return serverData.isDefinedNonNullNonEmpty(shelfToken.remainingItems) ? shelfToken.remainingItems : []; + } + const initialShelfContent = mediaRelationship.relationshipCollection(shelfToken.data, "contents"); + return serverData.isDefinedNonNullNonEmpty(initialShelfContent) ? initialShelfContent : []; +} +/** + * Find the related product data from some MAPI data that was programmed on an editorial page. + * + * @param objectGraph + * @param data + * @returns the product MAPI data from the correct relationship or the data itself if the supplied data is already a product + */ +export function extractProductData(objectGraph, data) { + let productData = null; + switch (data.type) { + case "editorial-items": + case "editorial-pages": + case "editorial-shelves-header": + productData = + mediaRelationship.relationshipData(objectGraph, data, "primary-content") || + mediaRelationship.relationshipData(objectGraph, data, "card-contents") || + mediaRelationship.relationshipData(objectGraph, data, "contents") || + mediaRelationship.relationshipData(objectGraph, data, "app"); + break; + case "apps": + case "in-apps": + case "app-bundles": + productData = data; + break; + default: + break; + } + return productData; +} +/** + * Find the related collection of product data from some MAPI data that was programmed on an editorial page. + * + * @param objectGraph + * @param data + * @returns collection of related content for in the relationship of the supplied MAPI data + */ +export function extractCollectionData(objectGraph, data) { + let collectionData = null; + switch (data.type) { + case "editorial-items": + case "editorial-pages": + case "editorial-shelves-header": + collectionData = + mediaRelationship.relationshipCollection(data, "primary-contents", true) || + mediaRelationship.relationshipCollection(data, "card-contents", true) || + mediaRelationship.relationshipCollection(data, "contents", true); + break; + case "tags": + collectionData = serverData.asArray(data.meta, "associations.apps.data"); + break; + default: + collectionData = null; + } + return collectionData; +} +/** + * Find the related editorial card used for determining override information + * + * @param objectGraph + * @param data + * @returns The editorial-card data object to use for overrides + */ +export function extractEditorialCardData(objectGraph, data) { + if (serverData.isNullOrEmpty(data)) { + return null; + } + const editorialCardsData = serverData.asArrayOrEmpty(data.meta, "associations.editorial-cards.data"); + if (serverData.isNullOrEmpty(editorialCardsData)) { + return null; + } + return editorialCardsData[0]; +} +/** + * Find the related editorial client params from this data object + * + * @param objectGraph + * @param data + * @returns The EditorialClientParams data object to use for this component + */ +export function extractEditorialClientParams(objectGraph, data) { + const baseEditorialClientParams = mediaAttributes.attributeAsDictionary(data, "editorialClientParams", {}); + const editorialCardData = extractEditorialCardData(objectGraph, data); + const cardEditorialClientParams = mediaAttributes.attributeAsDictionary(editorialCardData, "editorialClientParams", {}); + return serverData.asInterface({ + ...baseEditorialClientParams, + ...cardEditorialClientParams, + }); +} +/** + * Use the client params to create the display options for this component + * + * @param clientParams + * @returns The editorialDisplayOptions data object to use for this component + */ +export function editorialDisplayOptionsFromClientParams(clientParams) { + return { + showAppIcon: serverData.asBooleanWithDefault(clientParams.showAppIcon, false), + suppressLockup: serverData.asBooleanWithDefault(clientParams.suppressLockup, false), + useGeneratedBackground: serverData.asBooleanWithDefault(clientParams.useGeneratedBackground, false), + useMaterialBlur: serverData.asBooleanWithDefault(clientParams.useMaterialBlur, true), + useTextProtectionColor: serverData.asBooleanWithDefault(clientParams.useTextProtectionColor, false), + }; +} +/** + * Get the primary content for this MAPI data object, depending on the type it is. If the data + * does not have any attributes this method will return null, since we'll need to fetch it. + * @param objectGraph + * @param data + */ +export function extractHydratedPrimaryContentData(objectGraph, data) { + if (!mediaAttributes.hasAttributes(data)) { + return null; + } + let primaryData; + switch (data.type) { + case "editorial-items": + primaryData = content.primaryContentForData(objectGraph, data); + break; + default: + primaryData = data; + break; + } + if (!mediaAttributes.hasAttributes(primaryData)) { + return null; + } + return primaryData; +} +/** + * Method to check whether we need the primary content relationship for a piece of content + * to be rendered + * + * @param objectGraph + * @param data The MAPI date we're checking for + */ +export function requiresPrimaryContent(objectGraph, data) { + const linkData = mediaAttributes.attributeAsDictionary(data, "link"); + const isLinkAction = serverData.isDefinedNonNullNonEmpty(linkData); + const isStoryAction = mediaAttributes.attributeAsBooleanOrFalse(data, "isCanvasAvailable"); + return !isLinkAction && !isStoryAction; +} +/** + * Extracts the collection shelf display style, for any collection / recommendation shelf + * @param objectGraph Current object graph + * @param shelfData The input shelf data + * @returns The collection shelf display style, if any + */ +export function collectionShelfDisplayStyleFromShelfData(objectGraph, shelfData) { + const shelfType = shelfData.type; + if (shelfType !== EditorialShelfType.Collection && shelfType !== EditorialShelfType.Recommendations) { + return null; + } + return mediaAttributes.attributeAsString(shelfData, "displayStyle"); +} +//# sourceMappingURL=editorial-data-util.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-media-util.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-media-util.js new file mode 100644 index 0000000..218f74f --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-media-util.js @@ -0,0 +1,511 @@ +import { isNothing, isSome } from "@jet/environment/types/optional"; +import * as models from "../../api/models"; +import * as serverData from "../../foundation/json-parsing/server-data"; +import * as mediaAttributes from "../../foundation/media/attributes"; +import * as mediaPlatformAttributes from "../../foundation/media/platform-attributes"; +import * as videoDefaults from "../constants/video-constants"; +import * as contentAttributes from "../content/attributes"; +import * as content from "../content/content"; +import * as editorialDataUtil from "./editorial-data-util"; +import * as color from "../../foundation/util/color-util"; +/** + * The flavors for editorial art that can be used + */ +export var EditorialMediaFlavor; +(function (EditorialMediaFlavor) { + EditorialMediaFlavor["StoryCenteredMotion16x9"] = "storyCenteredMotion16x9"; + EditorialMediaFlavor["StoryCenteredStatic16x9"] = "storyCenteredStatic16x9"; + EditorialMediaFlavor["StoryDetailMotion3x4"] = "storyDetailMotion3x4"; + EditorialMediaFlavor["StoryDetailStatic3x4"] = "storyDetailStatic3x4"; + EditorialMediaFlavor["HeroMotion16x9"] = "heroMotion16x9"; + EditorialMediaFlavor["HeroStatic16x9"] = "heroStatic16x9"; + EditorialMediaFlavor["HeroMotionRTL16x9"] = "heroMotionRTL16x9"; + EditorialMediaFlavor["HeroStaticRTL16x9"] = "heroStaticRTL16x9"; + EditorialMediaFlavor["LargeBreakoutMotion16x9"] = "largeBreakoutMotion16x9"; + EditorialMediaFlavor["LargeBreakoutStatic16x9"] = "largeBreakoutStatic16x9"; + EditorialMediaFlavor["LargeBreakoutRTLMotion16x9"] = "largeBreakoutRTLMotion16x9"; + EditorialMediaFlavor["LargeBreakoutRTLStatic16x9"] = "largeBreakoutRTLStatic16x9"; + EditorialMediaFlavor["StoryCardMotion3x4"] = "storyCardMotion3x4"; + EditorialMediaFlavor["StoryCardStatic3x4"] = "storyCardStatic3x4"; + EditorialMediaFlavor["StorySearchStatic16x9"] = "storySearchStatic16x9"; + EditorialMediaFlavor["SubscriptionHero"] = "subscriptionHero"; + EditorialMediaFlavor["UniversalAMotion16x9"] = "universalAMotion16x9"; + EditorialMediaFlavor["UniversalAStatic16x9"] = "universalAStatic16x9"; + EditorialMediaFlavor["BrickStatic16x9"] = "brickStatic16x9"; + EditorialMediaFlavor["BrickStaticRTL16x9"] = "brickStaticRTL16x9"; + EditorialMediaFlavor["SearchCategoryBrick"] = "searchCategoryBrick"; +})(EditorialMediaFlavor || (EditorialMediaFlavor = {})); +/** + * The different locations for where editorial art is displayed + */ +export var EditorialMediaPlacement; +(function (EditorialMediaPlacement) { + EditorialMediaPlacement["Hero"] = "hero"; + EditorialMediaPlacement["LargeBreakout"] = "largeBreakout"; + EditorialMediaPlacement["StoryCard"] = "storyCard"; + EditorialMediaPlacement["StoryDetail"] = "storyDetail"; + EditorialMediaPlacement["StoryDetailLandscape"] = "storyDetailLandscape"; + EditorialMediaPlacement["Search"] = "search"; + EditorialMediaPlacement["Brick"] = "brick"; + EditorialMediaPlacement["EditorialLockup"] = "editorialLockup"; + EditorialMediaPlacement["EditorialPage"] = "editorialPage"; +})(EditorialMediaPlacement || (EditorialMediaPlacement = {})); +/** + * The mapping between the various placements and the preferred flavor for that location + */ +const preferredEditorialMediaFlavorMap = { + hero: [ + EditorialMediaFlavor.HeroMotion16x9, + EditorialMediaFlavor.HeroStatic16x9, + EditorialMediaFlavor.StoryCenteredMotion16x9, + EditorialMediaFlavor.StoryCenteredStatic16x9, + EditorialMediaFlavor.UniversalAMotion16x9, + EditorialMediaFlavor.UniversalAStatic16x9, + ], + largeBreakout: [ + EditorialMediaFlavor.LargeBreakoutMotion16x9, + EditorialMediaFlavor.LargeBreakoutStatic16x9, + EditorialMediaFlavor.StoryCenteredMotion16x9, + EditorialMediaFlavor.StoryCenteredStatic16x9, + EditorialMediaFlavor.UniversalAMotion16x9, + EditorialMediaFlavor.UniversalAStatic16x9, + ], + storyCard: [ + EditorialMediaFlavor.StoryCardMotion3x4, + EditorialMediaFlavor.StoryCardStatic3x4, + EditorialMediaFlavor.StoryCenteredMotion16x9, + EditorialMediaFlavor.StoryCenteredStatic16x9, + EditorialMediaFlavor.UniversalAMotion16x9, + EditorialMediaFlavor.UniversalAStatic16x9, + ], + storyDetail: [ + EditorialMediaFlavor.StoryDetailMotion3x4, + EditorialMediaFlavor.StoryDetailStatic3x4, + EditorialMediaFlavor.StoryCenteredMotion16x9, + EditorialMediaFlavor.StoryCenteredStatic16x9, + EditorialMediaFlavor.UniversalAMotion16x9, + EditorialMediaFlavor.UniversalAStatic16x9, + ], + storyDetailLandscape: [ + EditorialMediaFlavor.StoryCenteredMotion16x9, + EditorialMediaFlavor.StoryCenteredStatic16x9, + EditorialMediaFlavor.UniversalAMotion16x9, + EditorialMediaFlavor.UniversalAStatic16x9, + EditorialMediaFlavor.StoryDetailMotion3x4, + EditorialMediaFlavor.StoryDetailStatic3x4, + ], + search: [ + EditorialMediaFlavor.StorySearchStatic16x9, + EditorialMediaFlavor.StoryCenteredStatic16x9, + EditorialMediaFlavor.UniversalAStatic16x9, + ], + brick: [ + EditorialMediaFlavor.BrickStatic16x9, + EditorialMediaFlavor.HeroStatic16x9, + EditorialMediaFlavor.StoryCenteredStatic16x9, + EditorialMediaFlavor.UniversalAStatic16x9, + EditorialMediaFlavor.SearchCategoryBrick, + ], + editorialLockup: [EditorialMediaFlavor.SubscriptionHero], + editorialPage: [ + EditorialMediaFlavor.StoryCardStatic3x4, + EditorialMediaFlavor.HeroStatic16x9, + EditorialMediaFlavor.StoryCenteredStatic16x9, + EditorialMediaFlavor.SubscriptionHero, + ], +}; +/** + * The mapping between the various placements and the preferred flavor for that location, for RTL flavors + */ +const preferredEditorialMediaRTLFlavorMap = { + hero: [ + EditorialMediaFlavor.HeroMotionRTL16x9, + EditorialMediaFlavor.HeroStaticRTL16x9, + EditorialMediaFlavor.StoryCenteredMotion16x9, + EditorialMediaFlavor.StoryCenteredStatic16x9, + EditorialMediaFlavor.UniversalAMotion16x9, + EditorialMediaFlavor.UniversalAStatic16x9, + ], + largeBreakout: [ + EditorialMediaFlavor.LargeBreakoutRTLMotion16x9, + EditorialMediaFlavor.LargeBreakoutRTLStatic16x9, + EditorialMediaFlavor.StoryCenteredMotion16x9, + EditorialMediaFlavor.StoryCenteredStatic16x9, + EditorialMediaFlavor.UniversalAMotion16x9, + EditorialMediaFlavor.UniversalAStatic16x9, + ], + storyCard: [ + EditorialMediaFlavor.StoryCardMotion3x4, + EditorialMediaFlavor.StoryCardStatic3x4, + EditorialMediaFlavor.StoryCenteredMotion16x9, + EditorialMediaFlavor.StoryCenteredStatic16x9, + EditorialMediaFlavor.UniversalAMotion16x9, + EditorialMediaFlavor.UniversalAStatic16x9, + ], + storyDetail: [ + EditorialMediaFlavor.StoryDetailMotion3x4, + EditorialMediaFlavor.StoryDetailStatic3x4, + EditorialMediaFlavor.StoryCenteredMotion16x9, + EditorialMediaFlavor.StoryCenteredStatic16x9, + EditorialMediaFlavor.UniversalAMotion16x9, + EditorialMediaFlavor.UniversalAStatic16x9, + ], + storyDetailLandscape: [ + EditorialMediaFlavor.StoryCenteredMotion16x9, + EditorialMediaFlavor.StoryCenteredStatic16x9, + EditorialMediaFlavor.UniversalAMotion16x9, + EditorialMediaFlavor.UniversalAStatic16x9, + EditorialMediaFlavor.StoryDetailMotion3x4, + EditorialMediaFlavor.StoryDetailStatic3x4, + ], + search: [ + EditorialMediaFlavor.StorySearchStatic16x9, + EditorialMediaFlavor.StoryCenteredStatic16x9, + EditorialMediaFlavor.UniversalAStatic16x9, + ], + brick: [ + EditorialMediaFlavor.BrickStaticRTL16x9, + EditorialMediaFlavor.HeroStatic16x9, + EditorialMediaFlavor.StoryCenteredStatic16x9, + EditorialMediaFlavor.UniversalAStatic16x9, + EditorialMediaFlavor.SearchCategoryBrick, + ], + editorialLockup: [EditorialMediaFlavor.SubscriptionHero], + editorialPage: [ + EditorialMediaFlavor.StoryCardStatic3x4, + EditorialMediaFlavor.HeroStatic16x9, + EditorialMediaFlavor.StoryCenteredStatic16x9, + EditorialMediaFlavor.SubscriptionHero, + ], +}; +/** + * Create the best suitable editorial artwork / video for the given placement, including the additional data that might be + * needed about this artwork + * + * @param objectGraph + * @param data + * @param placement + */ +export function editorialMediaDataForPlacement(objectGraph, data, placement) { + const editorialCardData = editorialDataUtil.extractEditorialCardData(objectGraph, data); + const preferredEditorialMediaFlavors = preferredEditorialMediaFlavorMap[placement]; + const editorialMediaData = editorialMediaDataForPlacementAndFlavors(objectGraph, data, editorialCardData, placement, preferredEditorialMediaFlavors, false); + const preferredEditorialMediaRTLFlavors = preferredEditorialMediaRTLFlavorMap[placement]; + const rtlEditorialMediaData = editorialMediaDataForPlacementAndFlavors(objectGraph, data, editorialCardData, placement, preferredEditorialMediaRTLFlavors, true); + editorialMediaData.rtlArtwork = rtlEditorialMediaData.rtlArtwork; + editorialMediaData.rtlArtworkData = rtlEditorialMediaData.rtlArtworkData; + editorialMediaData.rtlVideo = rtlEditorialMediaData.rtlVideo; + editorialMediaData.rtlBackgroundColor = rtlEditorialMediaData.rtlBackgroundColor; + editorialMediaData.rtlTextColorOverride = rtlEditorialMediaData.rtlTextColorOverride; + return editorialMediaData; +} +/** + * Creates the `EditorialMediaData` object for a specific placement and flavors. + * + * Note: This will only populate either the LTR properties or the RTL properties on the `EditorialMediaData` + * object, never both. Which ones are populated is based on the `isRTL` flag. + * + * @param objectGraph Current object graph + * @param data The data blob for the main item + * @param editorialCardData The data blob for the editorial card + * @param placement The placement for the media + * @param flavors The flavor candidates for the media + * @param isRTL Whether the placement is for RTL media + * @returns A built `EditorialMediaData` object + */ +function editorialMediaDataForPlacementAndFlavors(objectGraph, data, editorialCardData, placement, flavors, isRTL) { + let editorialMediaData = {}; + for (const flavor of flavors) { + // Check the editorial card first for override media + if (serverData.isDefinedNonNull(editorialCardData)) { + editorialMediaData = + editorialVideoFromDataForFlavor(objectGraph, editorialCardData, placement, flavor, isRTL) || + editorialArtworkFromDataForFlavor(objectGraph, editorialCardData, placement, flavor, isRTL); + if (serverData.isDefinedNonNullNonEmpty(editorialMediaData)) { + break; + } + } + // If no override found, then check the main data + editorialMediaData = + editorialVideoFromDataForFlavor(objectGraph, data, placement, flavor, isRTL) || + editorialArtworkFromDataForFlavor(objectGraph, data, placement, flavor, isRTL); + if (serverData.isDefinedNonNullNonEmpty(editorialMediaData)) { + break; + } + } + if (isNothing(editorialMediaData)) { + editorialMediaData = {}; + } + return editorialMediaData; +} +/** + * Create the best suitable editorial artwork for the given flavor, including the additional data that might be + * needed about this artwork, returns null if there is no editorial artwork for this flavor + * + * @param objectGraph + * @param data + * @param placement + * @param flavor + * @param isRTL + */ +function editorialArtworkFromDataForFlavor(objectGraph, data, placement, flavor, isRTL) { + let editorialArtwork = null; + let editorialArtworkData = null; + let editorialArtworkBackgroundColor = null; + const editorialArtworkPath = `editorialArtwork.${flavor}`; + const attributePlatform = contentAttributes.bestAttributePlatformFromData(objectGraph, data); + if (serverData.isNull(attributePlatform)) { + return null; + } + editorialArtworkData = + mediaAttributes.attributeAsDictionary(data, editorialArtworkPath) || + mediaPlatformAttributes.platformAttributeAsDictionary(data, attributePlatform, editorialArtworkPath); + if (!serverData.isDefinedNonNullNonEmpty(editorialArtworkData)) { + return null; + } + editorialArtwork = content.artworkFromApiArtwork(objectGraph, editorialArtworkData, { + withJoeColorPlaceholder: true, + useCase: artworkUseCaseForPlacement(placement), + cropCode: cropCodeForPlacementAndFlavor(placement, flavor, isRTL), + }); + if (serverData.isNull(editorialArtwork)) { + return null; + } + editorialArtworkBackgroundColor = editorialArtwork.backgroundColor; + const textColorOverride = editorialTextColorOverride(objectGraph, editorialArtworkData, editorialArtwork); + if (isRTL) { + return { + rtlArtwork: editorialArtwork, + rtlArtworkData: editorialArtworkData, + rtlBackgroundColor: editorialArtworkBackgroundColor, + rtlTextColorOverride: textColorOverride, + }; + } + else { + return { + artwork: editorialArtwork, + artworkData: editorialArtworkData, + backgroundColor: editorialArtworkBackgroundColor, + textColorOverride: textColorOverride, + }; + } +} +/** + * Create the best suitable editorial artwork for the given flavor, including the additional data that might be + * needed about this artwork, returns null if there is no editorial artwork for this flavor + * + * @param objectGraph + * @param data + * @param placement + * @param flavor + */ +function editorialVideoFromDataForFlavor(objectGraph, data, placement, flavor, isRTL) { + let editorialVideo = null; + let previewFrameArtwork = null; + let editorialVideoData = null; + let editorialVideoBackgroundColor = null; + const editorialVideoPath = `editorialVideo.${flavor}`; + const attributePlatform = contentAttributes.bestAttributePlatformFromData(objectGraph, data); + if (isNothing(attributePlatform)) { + return null; + } + editorialVideoData = + mediaAttributes.attributeAsDictionary(data, editorialVideoPath) || + mediaPlatformAttributes.platformAttributeAsDictionary(data, attributePlatform, editorialVideoPath); + if (serverData.isNullOrEmpty(editorialVideoData)) { + return null; + } + const previewFrameData = serverData.asDictionary(editorialVideoData, "previewFrame"); + if (serverData.isDefinedNonNullNonEmpty(previewFrameData)) { + previewFrameArtwork = content.artworkFromApiArtwork(objectGraph, previewFrameData, { + withJoeColorPlaceholder: true, + useCase: artworkUseCaseForPlacement(placement), + cropCode: "sr", + }); + } + if (serverData.isDefinedNonNullNonEmpty(previewFrameArtwork)) { + previewFrameArtwork.crop = "sr"; + editorialVideoBackgroundColor = previewFrameArtwork.backgroundColor; + } + const videoUrl = serverData.asString(editorialVideoData, "video"); + if (serverData.isDefinedNonNullNonEmpty(previewFrameArtwork) && isSome(videoUrl) && videoUrl.length > 0) { + editorialVideo = new models.Video(videoUrl, previewFrameArtwork, { + canPlayFullScreen: false, + allowsAutoPlay: true, + looping: true, + playbackControls: videoPlaybackControls(objectGraph, placement), + autoPlayPlaybackControls: {}, + }); + editorialVideo.editorialMediaFlavor = flavor; + editorialVideo.editorialMediaPlacement = placement; + } + if (isNothing(previewFrameData) || isNothing(previewFrameArtwork)) { + return null; + } + const textColorOverride = editorialTextColorOverride(objectGraph, previewFrameData, previewFrameArtwork); + if (isRTL) { + return { + rtlVideo: editorialVideo, + rtlArtwork: previewFrameArtwork, + rtlArtworkData: previewFrameData, + rtlBackgroundColor: editorialVideoBackgroundColor, + rtlTextColorOverride: textColorOverride, + }; + } + else { + return { + video: editorialVideo, + artwork: previewFrameArtwork, + artworkData: previewFrameData, + backgroundColor: editorialVideoBackgroundColor, + textColorOverride: textColorOverride, + }; + } +} +/** + * Determine the correct artwork use case for each placement + * @param placement + */ +function artworkUseCaseForPlacement(placement) { + switch (placement) { + case EditorialMediaPlacement.Hero: + return 19 /* content.ArtworkUseCase.GroupingHero */; + case EditorialMediaPlacement.LargeBreakout: + return 6 /* content.ArtworkUseCase.ArcadeLargeBreakout */; + case EditorialMediaPlacement.StoryCard: + return 15 /* content.ArtworkUseCase.TodayCardMedia */; + case EditorialMediaPlacement.StoryDetail: + case EditorialMediaPlacement.StoryDetailLandscape: + return 13 /* content.ArtworkUseCase.ArticleImage */; + case EditorialMediaPlacement.Search: + return 9 /* content.ArtworkUseCase.SearchEditorialResult */; + default: + return 0 /* content.ArtworkUseCase.Default */; + } +} +/** + * Determine the correct crop code to use for artwork at a given flavor + * @param placement + * @param flavor + * @param isRTL + */ +function cropCodeForPlacementAndFlavor(placement, flavor, isRTL) { + switch (placement) { + case EditorialMediaPlacement.Hero: + switch (flavor) { + case EditorialMediaFlavor.HeroStatic16x9: + if (!isRTL) { + return "gd"; + } + break; + case EditorialMediaFlavor.HeroStaticRTL16x9: + if (isRTL) { + return "gg"; + } + break; + case EditorialMediaFlavor.StoryCenteredStatic16x9: + return isRTL ? "gh" : "ge"; + case EditorialMediaFlavor.UniversalAStatic16x9: + return isRTL ? "gj" : "gi"; + default: + break; + } + break; + case EditorialMediaPlacement.LargeBreakout: + switch (flavor) { + case EditorialMediaFlavor.StoryCenteredStatic16x9: + return isRTL ? "gk" : "gf"; + case EditorialMediaFlavor.UniversalAStatic16x9: + return isRTL ? "gl" : "gm"; + default: + break; + } + break; + case EditorialMediaPlacement.StoryCard: + case EditorialMediaPlacement.StoryDetail: + case EditorialMediaPlacement.StoryDetailLandscape: + case EditorialMediaPlacement.Search: + switch (flavor) { + case EditorialMediaFlavor.UniversalAStatic16x9: + return "gn"; + default: + break; + } + break; + case EditorialMediaPlacement.Brick: + switch (flavor) { + case EditorialMediaFlavor.SearchCategoryBrick: + return "SCB.ApSCBL01"; + default: + break; + } + break; + default: + break; + } + return "sr"; +} +/** + * Determines whether a given piece of editorial media is considered dark, light, or unknown. + * @param objectGraph Current object graph + * @param mediaData The data for the editorial media + * @param isRTL Whether the media to check is for RTL + * @returns True if the media is considered to be dark, false if considered light, or undefined if unknown. + */ +export function isMediaDark(objectGraph, editorialMediaData, isRTL = false) { + if (isNothing(editorialMediaData)) { + return null; + } + const textColorOverride = isRTL + ? editorialMediaData.rtlTextColorOverride + : editorialMediaData.textColorOverride; + const backgroundColor = isRTL + ? editorialMediaData.rtlBackgroundColor + : editorialMediaData.backgroundColor; + if (isSome(textColorOverride)) { + // Custom text colors can either be white or black. If the custom color is white, we set the + // media as dark, which will implicitly use white text. The behaviour is reversed for black text. + return color.isColorEqualToColor(textColorOverride, color.white); + } + else if (isSome(backgroundColor)) { + // If no custom text color is set, use the media background color to determine the darkness. + return color.isDarkColor(backgroundColor); + } + return null; +} +/** + * Determines if an editorially set custom text color should be used. + * @param objectGraph Current object graph + * @param artworkData The data that represents the editorial artwork + * @param artwork The parsed editorial artwork + * @returns True if the component should respect an editorial color + */ +function editorialTextColorOverride(objectGraph, artworkData, artwork) { + const textColor = artwork === null || artwork === void 0 ? void 0 : artwork.textColor; + if (isNothing(textColor)) { + return null; + } + const useCustomTextColor = serverData.asBooleanOrFalse(artworkData, "useCustomTextColor"); + const customTextColorIsValid = color.isColorEqualToColor(textColor, color.black) || color.isColorEqualToColor(textColor, color.white); + if (useCustomTextColor && customTextColorIsValid) { + return textColor; + } + return null; +} +/** + * Determines the video playback controls for a given placement. + * @param objectGraph Current object graph + * @param placement The placement for the view containing the video + * @returns The video playback controls + */ +function videoPlaybackControls(objectGraph, placement) { + switch (placement) { + case EditorialMediaPlacement.Hero: + case EditorialMediaPlacement.StoryDetail: + case EditorialMediaPlacement.StoryDetailLandscape: + return videoDefaults.noControls(objectGraph); + default: + return videoDefaults.standardControls(objectGraph); + } +} +//# sourceMappingURL=editorial-media-util.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-component-media-util.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-component-media-util.js new file mode 100644 index 0000000..9a39901 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-component-media-util.js @@ -0,0 +1,76 @@ +import * as serverData from "../../foundation/json-parsing/server-data"; +import * as lockups from "../lockups/lockups"; +import * as editorialDataUtil from "./editorial-data-util"; +import * as editorialMediaUtil from "./editorial-media-util"; +/** + * Get the editorial artwork / video data for a component on an editorial page + * @param objectGraph + * @param data + * @param collectionDisplayStyle + */ +export function editorialMediaDataFromData(objectGraph, data, collectionDisplayStyle) { + switch (collectionDisplayStyle) { + case "EditorialLockupMedium": + case "EditorialLockupLarge": + case "EditorialLockupMediumVariant": + case "EditorialLockupLargeVariant": + return editorialMediaUtil.editorialMediaDataForPlacement(objectGraph, data, editorialMediaUtil.EditorialMediaPlacement.EditorialLockup); + case "BrickSmall": + case "BrickMedium": + case "BrickLarge": + return editorialMediaUtil.editorialMediaDataForPlacement(objectGraph, data, editorialMediaUtil.EditorialMediaPlacement.Brick); + case "StoryMedium": + case "StorySmall": + return editorialMediaUtil.editorialMediaDataForPlacement(objectGraph, data, editorialMediaUtil.EditorialMediaPlacement.StoryCard); + case "Hero": + return editorialMediaUtil.editorialMediaDataForPlacement(objectGraph, data, editorialMediaUtil.EditorialMediaPlacement.Hero); + case "BreakoutLarge": + return editorialMediaUtil.editorialMediaDataForPlacement(objectGraph, data, editorialMediaUtil.EditorialMediaPlacement.LargeBreakout); + default: + return {}; + } +} +/** + * Get the app icons to display when there is no editorial artwork / video + * @param objectGraph + * @param data + * @param lockupOptions + */ +export function editorialFallbackAppIconsFromData(objectGraph, data, lockupOptions) { + const collectionLockups = editorialCollectionAppsFromData(objectGraph, data, { lockupOptions: lockupOptions }); + if (serverData.isNullOrEmpty(collectionLockups)) { + return undefined; + } + return collectionLockups === null || collectionLockups === void 0 ? void 0 : collectionLockups.map((lockup) => { + return lockup.icon; + }); +} +/** + * Get lockup to be displayed on an editorial component + * @param objectGraph + * @param data + * @param lockupOptions + */ +export function editorialAppLockupFromData(objectGraph, data, lockupOptions) { + const productData = editorialDataUtil.extractProductData(objectGraph, data); + if (serverData.isNullOrEmpty(productData)) { + return null; + } + const appLockup = lockups.lockupFromData(objectGraph, productData, lockupOptions); + return appLockup; +} +/** + * Get the lockups from the collection this data is pointing to for a component on an editorial page + * @param objectGraph + * @param data + * @param lockupOptions + */ +export function editorialCollectionAppsFromData(objectGraph, data, lockupOptions) { + const collectionData = editorialDataUtil.extractCollectionData(objectGraph, data); + if (serverData.isNullOrEmpty(collectionData)) { + return null; + } + const collectionApps = lockups.lockupsFromData(objectGraph, collectionData, lockupOptions); + return collectionApps; +} +//# sourceMappingURL=editorial-page-component-media-util.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-controller-util.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-controller-util.js new file mode 100644 index 0000000..db81f0d --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-controller-util.js @@ -0,0 +1,209 @@ +import { isNothing } from "@jet/environment"; +import * as editorialMediaUtil from "./editorial-media-util"; +import * as mediaAttributes from "../../foundation/media/attributes"; +import * as mediaDataFetching from "../../foundation/media/data-fetching"; +import * as mediaDataStructure from "../../foundation/media/data-structure"; +import * as mediaRelationship from "../../foundation/media/relationships"; +import * as metricsHelpersLocation from "../../common/metrics/helpers/location"; +import * as metricsHelpersPage from "../../common/metrics/helpers/page"; +import * as metricsHelpersUtil from "../../common/metrics/helpers/util"; +import * as models from "../../api/models"; +import * as onDevicePersonalization from "../../common/personalization/on-device-personalization"; +import * as refresh from "../../common/refresh/page-refresh-controller"; +import * as serverData from "../../foundation/json-parsing/server-data"; +import * as sharing from "../../common/sharing"; +import * as shelfBatching from "../../common/grouping/shelf-batching"; +import { createBaseShelfToken } from "./editorial-page-shelf-token"; +import { buildEditorialShelf } from "./editorial-page-shelf-builder"; +import { buildArcadeLockup } from "./editorial-page-shelf-builder/editorial-page-arcade-lockup-builder"; +import { shelfForTermsAndConditions } from "../grouping/grouping-common"; +import { EditorialShelfType } from "./editorial-page-types"; +/** + * Returns the number of shelves to hydrate on first load + */ +export function pageSparseCount(objectGraph) { + if (objectGraph.client.isWeb) { + // Returning `null` will avoid `Request` from setting the count at all + return null; + } + else { + return 5; + } +} +/** + * Returns the number of hydrated items in the hydrated shelves + */ +export function pageSparseLimit(objectGraph) { + return 12; +} +/** + * Modify request for a items fetched for grouping shelf items. (i.e. individual IDs). + * This should be ideally be in grouping builder's `prepareRequest`, but that would change how url-driven requests are configured. + * @param objectGraph + * @param request Request to modify. + */ +export function prepareMAPIRequest(objectGraph, request) { + const baseAttributes = ["editorialArtwork", "editorialVideo", "editorialClientParams"]; + const editorialItemsAttributes = [ + ...baseAttributes, + "showExpectedReleaseDate", + "expectedReleaseDateDisplayFormat", + "enrichedEditorialNotes", + "shortEditorialNotes", + ]; + const editorialPagesAttributes = [...baseAttributes, "enrichedEditorialNotes"]; + const contentAttributes = [ + ...baseAttributes, + "minimumOSVersion", + "screenshotsByType", + "videoPreviewsByType", + "expectedReleaseDateDisplayFormat", + "isAppleWatchSupported", + "minimumOSVersion", + "compatibilityControllerRequirement", + ]; + if (objectGraph.appleSilicon.isSupportEnabled) { + contentAttributes.push("macRequiredCapabilities"); + } + if (objectGraph.client.isMac) { + contentAttributes.push("hasMacIPAPackage"); + } + if (objectGraph.client.isVision) { + request.addingRelationshipLimit("editorial-shelves-collection:contents", 100); + } + if (objectGraph.client.isWeb) { + request.addingRelationshipLimit("editorial-shelves-collection:contents", 20); + } + const appsAttributes = [...contentAttributes]; + const features = ["personalization", "supportsCustomTextColor"]; + request + .includingAgeRestrictions() + .includingAdditionalPlatforms(mediaDataFetching.defaultAdditionalPlatformsForClient(objectGraph)) + .enablingFeatures(features) + .includingRelationshipsForUpsell(true) + .includingScopedAttributes("editorial-items", editorialItemsAttributes) + .includingScopedAttributes("editorial-pages", editorialPagesAttributes) + .includingScopedAttributes("apps", appsAttributes); +} +export function shareSheetActionFromData(objectGraph, editorialPageData) { + var _a; + const url = mediaAttributes.attributeAsString(editorialPageData, "url"); + const title = mediaAttributes.attributeAsString(editorialPageData, "editorialNotes.name"); + if (serverData.isNull(url) || serverData.isNull(title)) { + return null; + } + const subtitle = objectGraph.loc.string("SHARE_EDITORIAL_PAGE_SUBTITLE"); + const artwork = (_a = editorialMediaUtil.editorialMediaDataForPlacement(objectGraph, editorialPageData, editorialMediaUtil.EditorialMediaPlacement.EditorialPage)) === null || _a === void 0 ? void 0 : _a.artwork; + // Create share sheet model (bail out if unable to do so) + const shareData = sharing.shareSheetDataForGenericPage(objectGraph, title, url, subtitle, null, artwork); + if (isNothing(shareData)) { + return null; + } + const activities = sharing.shareSheetActivitiesForGenericPage(objectGraph, url); + return new models.ShareSheetAction(shareData, activities); +} +export async function renderPage(objectGraph, data, parameters) { + var _a, _b; + const editorialPageData = mediaDataStructure.dataFromDataContainer(objectGraph, data); + if (!serverData.isDefinedNonNullNonEmpty(editorialPageData)) { + return null; + } + const canvasData = mediaRelationship.relationshipCollection(editorialPageData, "canvas"); + if (!serverData.isDefinedNonNullNonEmpty(canvasData)) { + return null; + } + let pageType = "Editorial"; + const typeFromServer = serverData.asString(editorialPageData, "type"); + if (typeFromServer === "tags") { + pageType = "TagRoom"; + } + const metricsPageInformation = metricsHelpersPage.metricsPageInformationFromMediaApiResponse(objectGraph, pageType, editorialPageData.id, data); + const metricsLocationTracker = metricsHelpersLocation.newLocationTracker(); + const onDevicePersonalizationMetricsData = onDevicePersonalization.metricsData(objectGraph); + metricsPageInformation.recoMetricsData = metricsHelpersUtil.combinedRecoMetricsDataFromMetricsData(metricsPageInformation.recoMetricsData, null, onDevicePersonalizationMetricsData); + const pageRefreshController = refresh.newPageRefreshControllerFromResponse(data); + const { isArcadePage } = parameters; + const shelves = []; + let pageData = null; + let arcadeLockup = null; + if (serverData.isDefinedNonNull(editorialPageData.attributes)) { + pageData = { + id: editorialPageData.id, + type: editorialPageData.type, + attributes: editorialPageData.attributes, + relationships: editorialPageData.relationships, + meta: editorialPageData.meta, + }; + } + else { + return null; + } + let hasUpsellbreakout = false; + for (const shelfData of canvasData) { + const shelfIndex = shelves.length; + const shelfToken = createBaseShelfToken(objectGraph, pageData.id, shelfData, isArcadePage, shelfIndex, metricsPageInformation, metricsLocationTracker); + const shelf = buildEditorialShelf(objectGraph, pageData, shelfToken); + if (serverData.isNull(shelf)) { + continue; + } + if (shelves.length === 0) { + const existingPresentationHints = shelf.presentationHints; + shelf.presentationHints = { + ...existingPresentationHints, + isFirstShelf: true, + }; + } + if (shelfToken.type === EditorialShelfType.Upsell) { + hasUpsellbreakout = true; + } + if (shelf.contentType === "upsellBreakout") { + arcadeLockup = buildArcadeLockup(objectGraph, shelfToken); + } + shelves.push(shelf); + } + const page = isArcadePage ? new models.ArcadePage(shelves) : new models.GenericPage(shelves); + page.title = hasUpsellbreakout + ? null + : (_a = mediaAttributes.attributeAsString(editorialPageData, "editorialNotes.name")) !== null && _a !== void 0 ? _a : mediaAttributes.attributeAsString(editorialPageData, "name"); + page.canonicalURL = mediaAttributes.attributeAsString(editorialPageData, "url"); + page.shareAction = shareSheetActionFromData(objectGraph, editorialPageData); + page.pageRefreshPolicy = refresh.pageRefreshPolicyForController(objectGraph, pageRefreshController); + // Create the ArcadeLockup for Arcade's sticky header + if (isArcadePage && serverData.isDefinedNonNull(arcadeLockup)) { + page.subscriptionLockup = arcadeLockup; + } + if (isArcadePage) { + metricsPageInformation.isCrossfireReferralCandidate = true; + } + metricsHelpersPage.addMetricsEventsToPageWithInformation(objectGraph, page, metricsPageInformation); + if (objectGraph.client.isVision) { + page.presentationOptions.push("prefersRevealingPageTitleWhenNotRoot"); + } + const isLastShelfSeeAllGames = ((_b = shelves[shelves.length - 1]) === null || _b === void 0 ? void 0 : _b.contentType) === "arcadeFooter"; + if (objectGraph.client.deviceType !== "watch" && + objectGraph.client.deviceType !== "tv" && + !isLastShelfSeeAllGames) { + const url = objectGraph.bag.termsAndConditionsURL; + if (!serverData.isNull(url)) { + const termsAndConditionsShelf = shelfForTermsAndConditions(objectGraph, url); + shelves.push(termsAndConditionsShelf); + } + } + if (shelves.length > 0) { + const isLargeHeroBreakout = shelves[0].contentType === "largeHeroBreakout"; + const isUpsell = shelves[0].contentType === "upsellBreakout"; + const isHeroCarousel = shelves[0].contentType === "heroCarousel"; + const isMediaPageHeader = shelves[0].contentType === "mediaPageHeader"; + const shouldOverlayPageHeader = isLargeHeroBreakout || isUpsell || isHeroCarousel || isMediaPageHeader; + if (shouldOverlayPageHeader && !preprocessor.GAMES_TARGET) { + page.presentationOptions.push("prefersOverlayedPageHeader"); + } + if (isMediaPageHeader) { + page.presentationOptions.push("prefersNonStandardBackButton"); + page.presentationOptions.push("prefersHiddenPageTitle"); + } + } + shelfBatching.addBatchGroupsToPage(page); + return page; +} +//# sourceMappingURL=editorial-page-controller-util.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-editorial-copy-util.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-editorial-copy-util.js new file mode 100644 index 0000000..7e8da86 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-editorial-copy-util.js @@ -0,0 +1,247 @@ +import * as serverData from "../../foundation/json-parsing/server-data"; +import * as mediaAttributes from "../../foundation/media/attributes"; +import * as mediaPlatformAttributes from "../../foundation/media/platform-attributes"; +import * as contentAttributes from "../content/attributes"; +import * as editorialDataUtil from "./editorial-data-util"; +/** + * Get the text that should be displayed as the badge (some times referred to as caption) for + * an editorial component + * @param objectGraph + * @param data + * @param collectionDisplayStyle + */ +export function editorialBadgeFromData(objectGraph, data, collectionDisplayStyle) { + let editorialBadge = null; + let editorialBadgeOverride = null; + let editorialBadgePaths = []; + // Check the editorial card first for override content + const editorialCardData = editorialDataUtil.extractEditorialCardData(objectGraph, data); + switch (data.type) { + case "editorial-items": + case "editorial-pages": + case "editorial-shelves-header": + editorialBadgePaths = ["enrichedEditorialNotes.badge", "editorialNotes.badge", "label"]; + editorialBadge = findFirstMatchingString(objectGraph, data, editorialBadgePaths, false); + editorialBadgeOverride = findFirstMatchingString(objectGraph, editorialCardData, editorialBadgePaths, false); + break; + case "apps": + case "in-apps": + case "app-bundles": + editorialBadgePaths = ["editorialNotes.badge"]; + editorialBadge = findFirstMatchingString(objectGraph, data, editorialBadgePaths, true); + editorialBadgeOverride = findFirstMatchingString(objectGraph, editorialCardData, editorialBadgePaths, true); + break; + default: + break; + } + const badge = serverData.isDefinedNonNull(editorialBadgeOverride) ? editorialBadgeOverride : editorialBadge; + if (serverData.isNullOrEmpty(badge)) { + return null; + } + return badge; +} +/** + * Get the text that should be displayed as the title for + * an editorial component + * @param objectGraph + * @param data + * @param collectionDisplayStyle + */ +export function editorialTitleFromData(objectGraph, data, collectionDisplayStyle) { + let editorialTitle = null; + let editorialTitlePaths = []; + switch (collectionDisplayStyle) { + case "EditorialLockupMediumVariant": + case "EditorialLockupLargeVariant": + switch (data.type) { + case "editorial-items": + case "editorial-pages": + case "editorial-shelves-header": + editorialTitlePaths = ["enrichedEditorialNotes.name", "editorialNotes.name"]; + editorialTitle = attributeAsString(data, editorialTitlePaths); + break; + case "apps": + case "in-apps": + case "app-bundles": + editorialTitlePaths = ["editorialNotes.tagline"]; + editorialTitle = findFirstMatchingString(objectGraph, data, editorialTitlePaths, true); + break; + default: + break; + } + break; + default: + switch (data.type) { + case "editorial-items": + case "editorial-pages": + case "editorial-shelves-header": + editorialTitlePaths = ["enrichedEditorialNotes.name", "editorialNotes.name"]; + editorialTitle = findFirstMatchingString(objectGraph, data, editorialTitlePaths, false); + break; + case "tags": + case "apps": + case "in-apps": + case "app-bundles": + editorialTitlePaths = ["name"]; + editorialTitle = findFirstMatchingString(objectGraph, data, editorialTitlePaths, false); + break; + default: + break; + } + } + // Check the editorial card first for override content + const editorialCardData = editorialDataUtil.extractEditorialCardData(objectGraph, data); + const editorialTitleOverride = findFirstMatchingString(objectGraph, editorialCardData, editorialTitlePaths, false); + const title = serverData.isDefinedNonNull(editorialTitleOverride) ? editorialTitleOverride : editorialTitle; + if (serverData.isNullOrEmpty(title)) { + return null; + } + return title; +} +/** + * Get the text that should be displayed as the description for + * an editorial component + * @param objectGraph + * @param data + */ +export function editorialDescriptionFromData(objectGraph, data, preferHeroDescription = false) { + let editorialDescription = null; + let editorialDescriptionPaths = []; + switch (data.type) { + case "editorial-items": + if (preferHeroDescription) { + editorialDescriptionPaths = ["enrichedEditorialNotes.tagline", "editorialNotes.tagline"]; + } + else { + const ignoreShortNotes = mediaAttributes.attributeAsBooleanOrFalse(data, "ignoreITunesShortNotes"); + if (!ignoreShortNotes) { + editorialDescriptionPaths = ["enrichedEditorialNotes.short", "editorialNotes.short"]; + } + } + editorialDescription = findFirstMatchingString(objectGraph, data, editorialDescriptionPaths, false); + break; + case "editorial-pages": + case "editorial-shelves-header": + editorialDescriptionPaths = ["enrichedEditorialNotes.tagline", "editorialNotes.tagline"]; + editorialDescription = findFirstMatchingString(objectGraph, data, editorialDescriptionPaths, false); + break; + case "apps": + case "in-apps": + case "app-bundles": + editorialDescriptionPaths = ["editorialNotes.tagline"]; + editorialDescription = findFirstMatchingString(objectGraph, data, editorialDescriptionPaths, true); + break; + default: + break; + } + // Check the editorial card first for override content + const editorialCardData = editorialDataUtil.extractEditorialCardData(objectGraph, data); + const editorialDescriptionOverride = findFirstMatchingString(objectGraph, editorialCardData, editorialDescriptionPaths, false); + const description = serverData.isDefinedNonNull(editorialDescriptionOverride) + ? editorialDescriptionOverride + : editorialDescription; + if (serverData.isNullOrEmpty(description)) { + return null; + } + return description; +} +/** + * Get the text that should be displayed as the call to action on a button for + * an editorial component + * @param objectGraph + * @param data + */ +export function editorialCallToActionFromData(objectGraph, data) { + let editorialCallToAction = null; + let editorialCallToActionPaths = []; + switch (data.type) { + case "editorial-items": + case "editorial-pages": + case "editorial-shelves-header": + editorialCallToActionPaths = ["enrichedEditorialNotes.callToAction", "editorialNotes.callToAction"]; + editorialCallToAction = findFirstMatchingString(objectGraph, data, editorialCallToActionPaths, false); + break; + case "apps": + case "in-apps": + case "app-bundles": + editorialCallToActionPaths = ["enrichedEditorialNotes.callToAction", "editorialNotes.callToAction"]; + editorialCallToAction = findFirstMatchingString(objectGraph, data, editorialCallToActionPaths, true); + break; + default: + break; + } + // Check the editorial card first for override content + const editorialCardData = editorialDataUtil.extractEditorialCardData(objectGraph, data); + const editorialCallToActionOverride = findFirstMatchingString(objectGraph, editorialCardData, editorialCallToActionPaths, false); + let callToAction = null; + if ((editorialCallToActionOverride === null || editorialCallToActionOverride === void 0 ? void 0 : editorialCallToActionOverride.length) > 0) { + callToAction = editorialCallToActionOverride; + } + else if (serverData.isDefinedNonNullNonEmpty(editorialCallToAction)) { + callToAction = editorialCallToAction; + } + else { + if (preprocessor.GAMES_TARGET) { + callToAction = objectGraph.loc.string("Card.Collection.ActionButton.Title"); + } + else { + callToAction = objectGraph.loc.string("HERO_CAROUSEL_OVERLAY_BUTTON_TITLE_VIEW"); + } + } + return callToAction; +} +// region Debug Helpers +/** + * Retrieve the specified attribute from the data as a string. + * + * @param data The data from which to retrieve the attribute. + * @param attributePath The object path for the attribute. + * @returns {string} The attribute value as a string. + */ +function attributeAsString(data, attributePath) { + if (serverData.isNullOrEmpty(data)) { + return null; + } + return mediaAttributes.attributeAsString(data, attributePath); +} +/** + * Retrieve the specified attribute from the data as a string. Returning the path if null or missing + * + * If the attribute lives under the platform-specific attributes, then a platform may be provided to properly call in to + * the nested structure. + * @param data The data from which to retrieve the attribute. + * @param platform The platform to look up + * @param attributePath The object path for the attribute. + * @returns {string} The attribute value as a string. + */ +export function platformAttributeAsString(data, platform, attributePath) { + if (serverData.isNullOrEmpty(data)) { + return null; + } + return mediaPlatformAttributes.platformAttributeAsString(data, platform, attributePath); +} +/** + * Retrieve the specified attribute from the data as a string. Trying to find the best match for the given paths. + * @param objectGraph The object graph to use lookups + * @param mediaApiData The media data to use to query for the string + * @param stringPaths The different paths to try to find the string + * @param usePlatformAttributes Whether to check the platform attributes or not + * @returns The first matching string or null if none found + */ +function findFirstMatchingString(objectGraph, mediaApiData, stringPaths, usePlatformAttributes) { + if (serverData.isNullOrEmpty(mediaApiData)) { + return null; + } + const attributePlatform = contentAttributes.bestAttributePlatformFromData(objectGraph, mediaApiData); + for (const path of stringPaths) { + const matchingString = usePlatformAttributes + ? platformAttributeAsString(mediaApiData, attributePlatform, path) + : attributeAsString(mediaApiData, path); + if (serverData.isDefinedNonNullNonEmpty(matchingString)) { + return matchingString; + } + } + return null; +} +// endregion +//# sourceMappingURL=editorial-page-editorial-copy-util.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-hero-util.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-hero-util.js new file mode 100644 index 0000000..7ecca30 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-hero-util.js @@ -0,0 +1,88 @@ +import { isSome } from "@jet/environment/types/optional"; +import * as models from "../../api/models"; +import * as serverData from "../../foundation/json-parsing/server-data"; +import * as mediaAttributes from "../../foundation/media/attributes"; +import * as mediaDataStructure from "../../foundation/media/data-structure"; +import * as content from "../content/content"; +import * as heroCarouselOverlayCommon from "../grouping/hero/hero-carousel-overlay-common"; +import { deepLinkUrlFromData } from "../linking/external-deep-link"; +import * as lockups from "../lockups/lockups"; +import * as metricsHelpersImpressions from "../metrics/helpers/impressions"; +import * as editorialComponentMediaUtil from "./editorial-page-component-media-util"; +import * as editorialCopyUtil from "./editorial-page-editorial-copy-util"; +import * as editorialOverlayContentUtil from "./editorial-page-overlay-content-util"; +import { CollectionShelfDisplayStyle } from "./editorial-page-types"; +// region Overlay +export function heroOverlayFromData(objectGraph, data, shelfToken, editorialClientParams) { + const heroCarouselItemOverlay = new models.HeroCarouselItemOverlay(); + heroCarouselItemOverlay.overlayType = heroCarouselOverlayCommon.overlayTypeFromData(objectGraph, data); + heroCarouselItemOverlay.displayOptions = { + horizontalPlacement: "leading", + textAlignment: "leading", + isOverDarkContent: heroCarouselOverlayCommon.overlayIsOverDarkContent(objectGraph, data), + }; + heroCarouselItemOverlay.badgeText = editorialCopyUtil.editorialBadgeFromData(objectGraph, data, CollectionShelfDisplayStyle.Hero); + heroCarouselItemOverlay.titleText = editorialCopyUtil.editorialTitleFromData(objectGraph, data, CollectionShelfDisplayStyle.Hero); + if (!editorialClientParams.suppressTagline) { + heroCarouselItemOverlay.descriptionText = editorialCopyUtil.editorialDescriptionFromData(objectGraph, data, true); + } + heroCarouselItemOverlay.callToActionText = editorialCopyUtil.editorialCallToActionFromData(objectGraph, data); + heroCarouselItemOverlay.buttonTitle = heroCarouselOverlayCommon.overlayButtonTitleFromData(objectGraph, data); + const lockupOptions = { + metricsOptions: { + pageInformation: shelfToken.metricsPageInformation, + locationTracker: shelfToken.metricsLocationTracker, + targetType: "lockupSmall", + recoMetricsData: mediaDataStructure.metricsFromMediaApiObject(data), + }, + metricsClickOptions: { + id: data.id, + pageInformation: shelfToken.metricsPageInformation, + locationTracker: shelfToken.metricsLocationTracker, + actionDetails: { + franchise: heroCarouselItemOverlay.badgeText, + }, + }, + artworkUseCase: 1 /* content.ArtworkUseCase.LockupIconSmall */, + offerEnvironment: "dark", + canDisplayArcadeOfferButton: content.shelfDisplayStyleCanDisplayArcadeOfferButtons(objectGraph, shelfToken.collectionDisplayStyle), + isContainedInPreorderExclusiveShelf: false, + externalDeepLinkUrl: deepLinkUrlFromData(objectGraph, data), + }; + const appLockup = editorialComponentMediaUtil.editorialAppLockupFromData(objectGraph, data, lockupOptions); + const overlayContent = editorialOverlayContentUtil.extractOverlayContent(objectGraph, data, lockupOptions); + heroCarouselItemOverlay.lockup = overlayContent.lockup; + heroCarouselItemOverlay.collectionIcons = overlayContent.collectionIcons; + // If this EI can and should show the expected release date of an arcade app, override the badge. + const fallbackLabel = mediaAttributes.attributeAsString(data, "label"); + // For hero items the design is to use editorial labels instead of "Apple Arcade" so we replace that text here + if (serverData.isDefinedNonNullNonEmpty(fallbackLabel) && serverData.isDefinedNonNull(appLockup)) { + appLockup.heading = fallbackLabel; + } + const suppressLockup = isSome(editorialClientParams.suppressLockup) && editorialClientParams.suppressLockup; + if (serverData.isDefinedNonNullNonEmpty(heroCarouselItemOverlay.lockup) && !suppressLockup) { + heroCarouselItemOverlay.clickAction = heroCarouselItemOverlay.lockup.clickAction; + heroCarouselItemOverlay.impressionMetrics = heroCarouselItemOverlay.lockup.impressionMetrics; + } + else { + const heroCarouselItemOverlayMetricsOptions = { + targetType: "hero", + pageInformation: shelfToken.metricsPageInformation, + locationTracker: shelfToken.metricsLocationTracker, + recoMetricsData: mediaDataStructure.metricsFromMediaApiObject(data), + }; + const heroCarouselOverlayItemClickOptions = { + ...heroCarouselItemOverlayMetricsOptions, + id: data.id, + actionDetails: { + franchise: heroCarouselItemOverlay.badgeText, + }, + }; + heroCarouselItemOverlay.clickAction = lockups.editorialItemActionFromData(objectGraph, data, heroCarouselOverlayItemClickOptions, shelfToken.clientIdentifierOverride); + const heroCarouselItemOverlayImpressionsOptions = metricsHelpersImpressions.impressionOptions(objectGraph, data, heroCarouselItemOverlay.titleText, heroCarouselItemOverlayMetricsOptions); + metricsHelpersImpressions.addImpressionFields(objectGraph, heroCarouselItemOverlay, heroCarouselItemOverlayImpressionsOptions); + } + return heroCarouselItemOverlay; +} +// endregion +//# sourceMappingURL=editorial-page-hero-util.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-intent-controller-utils.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-intent-controller-utils.js new file mode 100644 index 0000000..e3c2690 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-intent-controller-utils.js @@ -0,0 +1,5 @@ +import { generateRoutes } from "../util/generate-routes"; +import { makeEditorialPageIntentByID } from "../../api/intents/editorial/editorial-page-intent"; +const { routes: editorialPageRoutes, makeCanonicalUrl: makeEditorialPageURL } = generateRoutes(makeEditorialPageIntentByID, "/{platform}/editorial/{id}"); +export { editorialPageRoutes, makeEditorialPageURL }; +//# sourceMappingURL=editorial-page-intent-controller-utils.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-lockup-utils.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-lockup-utils.js new file mode 100644 index 0000000..35e1cf9 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-lockup-utils.js @@ -0,0 +1,91 @@ +// region Lockup Creation +import * as serverData from "../../foundation/json-parsing/server-data"; +import * as mediaDataStructure from "../../foundation/media/data-structure"; +import * as content from "../content/content"; +import * as adLockups from "../lockups/ad-lockups"; +import * as lockups from "../lockups/lockups"; +import { clickTargetForCollectionDisplayStyle } from "./editorial-action-util"; +import { CollectionShelfFilterOverride } from "./editorial-page-types"; +import { isNothing } from "@jet/environment/types/optional"; +// region Lockup Creation +/** + * Create a lockup for shelfContents to display within an editorial page shelf + * @param objectGraph + * @param lockupData shelfContents to create lockup for. + * @param shelfToken Shelf shelfToken + * @param itemPosition The position of the item in the shelf + * @param collectionDisplayStyle The collection display style + */ +export function lockupFromData(objectGraph, lockupData, shelfToken, itemPosition, collectionDisplayStyle) { + if (serverData.isNullOrEmpty(lockupData)) { + return null; + } + // Set the ordinal + let ordinalString; + if (shelfToken.showOrdinals) { + ordinalString = objectGraph.loc.decimal(shelfToken.ordinalIndex); + } + let offerStyle = null; + if (serverData.isDefinedNonNull(shelfToken.shelfBackground) && + (shelfToken.shelfBackground.type === "color" || shelfToken.shelfBackground.type === "interactive")) { + offerStyle = "white"; + } + let clientIdentifierOverride; + if (serverData.isDefinedNonNullNonEmpty(shelfToken)) { + clientIdentifierOverride = shelfToken.clientIdentifierOverride; + } + const contentMetricsOptions = { + ...shelfToken.metricsImpressionOptions, + id: lockupData.id, + idType: "its_id", + }; + // Create the lockup + const lockupOptions = { + ordinal: ordinalString, + metricsOptions: { + ...contentMetricsOptions, + recoMetricsData: mediaDataStructure.metricsFromMediaApiObject(lockupData), + isAdvert: adLockups.isAdvert(objectGraph, lockupData), + targetType: clickTargetForCollectionDisplayStyle(objectGraph, collectionDisplayStyle), + }, + clientIdentifierOverride: clientIdentifierOverride, + artworkUseCase: 0 /* content.ArtworkUseCase.Default */, + offerStyle: offerStyle, + canDisplayArcadeOfferButton: content.shelfDisplayStyleCanDisplayArcadeOfferButtons(objectGraph, collectionDisplayStyle), + isContainedInPreorderExclusiveShelf: shelfToken.filterOverrides.includes(CollectionShelfFilterOverride.ShowOnlyPreorder), + }; + let lockup; + switch (collectionDisplayStyle) { + case "EditorialLockupMediumVariant": + case "EditorialLockupMedium": + case "EditorialLockupLargeVariant": + case "EditorialLockupLarge": + lockupOptions.offerEnvironment = "light"; + lockup = lockups.imageLockupFromData(objectGraph, lockupData, lockupOptions, collectionDisplayStyle); + break; + case "Poster": + lockup = lockups.posterLockupFromData(objectGraph, lockupData, lockupOptions); + break; + default: + lockup = lockups.lockupFromData(objectGraph, lockupData, lockupOptions); + } + if (serverData.isNull(lockup) || !lockup.isValid()) { + return null; + } + lockup.id = lockupIdentifier(shelfToken, itemPosition, lockup.adamId); + return lockup; +} +/** + * @param shelfToken The shelf token + * @param itemPosition The position of the item in the shelf + * @param adamId The adamID associated with the lockup + * @returns A string for uniquely identifying the lockup in this shelf + */ +function lockupIdentifier(shelfToken, itemPosition, adamId) { + if (isNothing(adamId)) { + return null; + } + return `${shelfToken.id}_${itemPosition}_${adamId}`; +} +// endregion +//# sourceMappingURL=editorial-page-lockup-utils.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-media-api-utils.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-media-api-utils.js new file mode 100644 index 0000000..42e838a --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-media-api-utils.js @@ -0,0 +1,39 @@ +import * as editorialPageControllerUtil from "./editorial-page-controller-util"; +import { Request as MediaAPIRequest, defaultAdditionalPlatformsForClient } from "../../foundation/media/data-fetching"; +import { Parameters } from "../../foundation/network/url-constants"; +import { shouldFetchCustomAttributes } from "../product-page/product-page-variants"; +import { isEditorialPageIntentByName, } from "../../api/intents/editorial/editorial-page-intent"; +import { setPreviewPlatform } from "../preview-platform"; +export function makeEditorialPageRequest(objectGraph, intent) { + const mediaApiRequest = makeBaseMediaAPIRequest(objectGraph, intent); + if (isEditorialPageIntentByName(intent)) { + mediaApiRequest.addingQuery(Parameters.name, intent.name); + } + else { + mediaApiRequest.withIdOfType(intent.id, "editorial-pages"); + } + prepareMediaAPIRequest(objectGraph, mediaApiRequest); + setPreviewPlatform(objectGraph, mediaApiRequest); + return mediaApiRequest; +} +function makeBaseMediaAPIRequest(objectGraph, locale) { + return new MediaAPIRequest(objectGraph, `/v1/editorial/${locale.storefront}`).forType("editorial-pages"); +} +function prepareMediaAPIRequest(objectGraph, mediaApiRequest) { + mediaApiRequest.includingAdditionalPlatforms(defaultAdditionalPlatformsForClient(objectGraph)); + mediaApiRequest.usingCustomAttributes(shouldFetchCustomAttributes(objectGraph)); + // <rdar://53420717> For performance reasons, we limit shelves to 3 items on watchOS. + if (objectGraph.client.isWatch) { + mediaApiRequest.addingRelationshipLimit("contents", 3); + } + mediaApiRequest + .includingAgeRestrictions() + .includingScopedRelationships("editorial-shelves", ["contents"]) + .includingScopedRelationships("editorial-pages", ["primary-contents"]) + .includingRelationships(["canvas"]) + .withSparseCount(editorialPageControllerUtil.pageSparseCount(objectGraph)) + .withSparseLimit(editorialPageControllerUtil.pageSparseLimit(objectGraph)) + .includingAssociateKeys("editorial-shelves-collection:contents", ["editorial-cards"]); + editorialPageControllerUtil.prepareMAPIRequest(objectGraph, mediaApiRequest); +} +//# sourceMappingURL=editorial-page-media-api-utils.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-overlay-content-util.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-overlay-content-util.js new file mode 100644 index 0000000..f76d85a --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-overlay-content-util.js @@ -0,0 +1,20 @@ +import * as serverData from "../../foundation/json-parsing/server-data"; +import { popLocation, pushBasicLocation } from "../metrics/helpers/location"; +import * as editorialComponentMediaUtil from "./editorial-page-component-media-util"; +export function extractOverlayContent(objectGraph, itemData, lockupOptions) { + const overlayContent = {}; + pushBasicLocation(objectGraph, lockupOptions.metricsOptions, "collectionIcons"); + const collectionIcons = editorialComponentMediaUtil.editorialFallbackAppIconsFromData(objectGraph, itemData, lockupOptions); + popLocation(lockupOptions.metricsOptions.locationTracker); + const appLockup = editorialComponentMediaUtil.editorialAppLockupFromData(objectGraph, itemData, lockupOptions); + if (serverData.isDefinedNonNullNonEmpty(collectionIcons) && + (collectionIcons.length > 1 || serverData.isNullOrEmpty(appLockup))) { + overlayContent.collectionIcons = collectionIcons; + } + else if (serverData.isDefinedNonNull(appLockup)) { + overlayContent.lockup = appLockup; + overlayContent.collectionIcons = [appLockup.icon]; + } + return overlayContent; +} +//# sourceMappingURL=editorial-page-overlay-content-util.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-arcade-lockup-builder.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-arcade-lockup-builder.js new file mode 100644 index 0000000..edb539c --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-arcade-lockup-builder.js @@ -0,0 +1,17 @@ +import * as models from "../../../api/models"; +import * as serverData from "../../../foundation/json-parsing/server-data"; +import * as arcadeCommon from "../../arcade/arcade-common"; +import * as lockups from "../../lockups/lockups"; +export function buildArcadeLockup(objectGraph, upsellBreakoutShelfToken) { + const metricsOptions = { + pageInformation: upsellBreakoutShelfToken.metricsPageInformation, + locationTracker: upsellBreakoutShelfToken.metricsLocationTracker, + }; + const upsellData = arcadeCommon.upsellFromRelationshipOf(objectGraph, upsellBreakoutShelfToken.data); + if (serverData.isNullOrEmpty(upsellData)) { + return null; + } + const arcadeLockup = lockups.arcadeLockupFromData(objectGraph, upsellData, metricsOptions, models.marketingItemContextFromString("arcadeTabHeader"), "colored", objectGraph.client.isMac ? "arcade" : "navigationBar"); + return arcadeLockup; +} +//# sourceMappingURL=editorial-page-arcade-lockup-builder.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-arcade-see-all-games-shelf-builder.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-arcade-see-all-games-shelf-builder.js new file mode 100644 index 0000000..a197c19 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-arcade-see-all-games-shelf-builder.js @@ -0,0 +1,71 @@ +import * as arcadeCommon from "../../arcade/arcade-common"; +import * as color from "../../../foundation/util/color-util"; +import * as content from "../../content/content"; +import * as editorialDataUtil from "../editorial-data-util"; +import * as metricsHelpersImpressions from "../../metrics/helpers/impressions"; +import * as metricsHelpersLocation from "../../metrics/helpers/location"; +import * as models from "../../../api/models"; +import * as serverData from "../../../foundation/json-parsing/server-data"; +import * as gamesComponentBuilder from "../../../gameservicesui/src/editorial-page/editorial-component-builder"; +export function buildArcadeSeeAllGamesShelf(objectGraph, shelfToken) { + const footer = new models.ArcadeFooter(); + const shelf = new models.Shelf("arcadeFooter"); + shelf.items = [footer]; + const impressionOptions = { + targetType: "arcadeSeeAllGamesFooter", + pageInformation: shelfToken.metricsPageInformation, + locationTracker: shelfToken.metricsLocationTracker, + title: objectGraph.loc.string("Arcade.SeeAllGames.Button.Title"), + id: shelfToken.id, + kind: "footer", + softwareType: "Arcade", + }; + metricsHelpersImpressions.addImpressionFields(objectGraph, footer, impressionOptions); + metricsHelpersLocation.pushContentLocation(objectGraph, impressionOptions, impressionOptions.title); + if (preprocessor.GAMES_TARGET) { + footer.buttonAction = gamesComponentBuilder.makeArcadeSeeAllAction(objectGraph); + } + else { + footer.buttonAction = arcadeCommon.seeAllArcadeGamesPageFlowAction(objectGraph, "releaseDate", shelfToken.metricsPageInformation, shelfToken.metricsLocationTracker); + } + const buttonImpressionOptions = { + targetType: "button", + pageInformation: shelfToken.metricsPageInformation, + locationTracker: shelfToken.metricsLocationTracker, + title: footer.buttonAction.title, + id: "SeeAllGames", + kind: "button", + softwareType: "Arcade", + }; + metricsHelpersImpressions.addImpressionFields(objectGraph, footer.buttonAction, buttonImpressionOptions); + metricsHelpersLocation.popLocation(impressionOptions.locationTracker); + const termsAndConditionsUrl = objectGraph.bag.termsAndConditionsURL; + const shouldAddTermsAndConditions = !serverData.isNull(termsAndConditionsUrl) && objectGraph.client.deviceType !== "tv"; + if (shouldAddTermsAndConditions) { + const termsAndConditionTitle = objectGraph.loc.string("TermsAndConditions.Title"); + const urlAction = new models.ExternalUrlAction(termsAndConditionsUrl); + const footnote = new models.Footnote(termsAndConditionTitle); + footnote.clickAction = urlAction; + footnote.presentationStyle = ["hasChevron", "textLightensOnHighlight", "hasSeparator"]; + footer.footnote = footnote; + } + shelf.background = { + type: "color", + color: color.named("placeholderBackground"), + }; + const shelfContents = editorialDataUtil.extractRemainingItemsOrInitialShelfContents(objectGraph, shelfToken); + if (serverData.isDefinedNonNullNonEmpty(shelfContents)) { + const metricsOptions = { + pageInformation: shelfToken.metricsPageInformation, + locationTracker: shelfToken.metricsLocationTracker, + }; + footer.icons = content.impressionableAppIconsFromDataCollection(objectGraph, shelfContents, metricsOptions, { + useCase: 2 /* content.ArtworkUseCase.LockupIconMedium */, + }); + } + else { + footer.icons = []; + } + return shelf; +} +//# sourceMappingURL=editorial-page-arcade-see-all-games-shelf-builder.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-chart-shelf-builder.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-chart-shelf-builder.js new file mode 100644 index 0000000..58e6862 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-chart-shelf-builder.js @@ -0,0 +1,106 @@ +import { isNothing, isSome } from "@jet/environment"; +import * as models from "../../../api/models"; +import { attributeAsString } from "../../../foundation/media/attributes"; +import { chartUrlFromData } from "../../content/content"; +import { addClickEventToSeeAllAction } from "../../metrics/helpers/clicks"; +import { insertPlaceholdersIntoShelfIfRequired } from "../../placeholders/placeholders"; +import { CollectionShelfLayoutDirection } from "../editorial-page-types"; +import { createShelfTokenUrlIfNecessary } from "./editorial-page-collection-shelf-builder/editorial-page-collection-shelf-common"; +import { buildLockupChartShelf, buildLockupSmallShelf, } from "./editorial-page-collection-shelf-builder/editorial-page-lockup-collection-shelf-builder"; +import { viewChartListActionWithGames } from "../../../gameservicesui/src/intent-controllers/page/charts-list-page-intent-controller"; +import * as editorialDataUtil from "../editorial-data-util"; +import { makeGamesFromCollection } from "../../../gameservicesui/src/models/cards/collection-card"; +export function buildChartShelf(objectGraph, shelfToken) { + var _a; + shelfToken.showOrdinals = true; + let shelf; + if (preprocessor.GAMES_TARGET) { + shelf = buildLockupChartShelf(objectGraph, shelfToken); + } + else { + /// Currently the charts shelf doesn't return a `displayStyle`, we only support LockupSmall. + shelf = buildLockupSmallShelf(objectGraph, shelfToken, false, CollectionShelfLayoutDirection.Horizontal); + } + if (isNothing(shelf)) { + return undefined; + } + shelf.url = createShelfTokenUrlIfNecessary(objectGraph, shelf, shelfToken); + insertPlaceholdersIntoShelfIfRequired(objectGraph, shelf, shelfToken); + if (preprocessor.GAMES_TARGET) { + if (isSome(shelf.header)) { + shelf.header.titleAction = (_a = chartPageSeeAllActionForGames(objectGraph, shelfToken)) !== null && _a !== void 0 ? _a : undefined; + } + else { + shelf.seeAllAction = chartPageSeeAllActionForGames(objectGraph, shelfToken); + } + shelf.id = `shelf_${shelfToken.id}`; + } + else { + replaceShelfSeeAllAction(objectGraph, shelf, chartPageSeeAllAction(objectGraph, shelfToken)); + } + return shelf; +} +function chartPageSeeAllActionForGames(objectGraph, shelfToken) { + var _a; + const gamesData = editorialDataUtil.extractRemainingItemsOrInitialShelfContents(objectGraph, shelfToken); + const games = makeGamesFromCollection(objectGraph, gamesData, {}, {}); + const genre = attributeAsString(shelfToken.data, "genre"); + const chart = attributeAsString(shelfToken.data, "chart"); + if (isSome(games) && isSome(genre) && isSome(chart)) { + const chartUrl = chartUrlFromData(objectGraph, genre, chart); + return viewChartListActionWithGames(games, shelfToken.title, (_a = shelfToken.subtitle) !== null && _a !== void 0 ? _a : "", chartUrl, shelfToken.data.id, // TODO: provide real `reco_id` rdar://133659618 ([Play Now Feed] Use metrics.meta.reco_id from shelf meta in metrics) + objectGraph); + } + return null; +} +function chartPageSeeAllAction(objectGraph, shelfToken) { + const genre = attributeAsString(shelfToken.data, "genre"); + const chart = attributeAsString(shelfToken.data, "chart"); + const action = new models.FlowAction("page"); + action.pageUrl = chartUrlFromData(objectGraph, genre, chart); + action.title = objectGraph.loc.string("ACTION_SEE_ALL"); + action.referrerUrl = shelfToken.metricsPageInformation.pageUrl; + addClickEventToSeeAllAction(objectGraph, action, action.pageUrl, { + pageInformation: shelfToken.metricsPageInformation, + locationTracker: shelfToken.metricsLocationTracker, + }); + return action; +} +/** + * Update the shelf header to use the provided seeAll action. + * @param objectGraph The App Store object graph used to check feature flags + * @param shelfHeader The shelf header to update + * @param seeAllAction The "See All" action to apply + */ +export function replaceShelfHeaderSeeAllAction(objectGraph, shelfHeader, seeAllAction) { + if (objectGraph.featureFlags.isEnabled("shelf_header")) { + // Modern headers make title tappable with a chevron (>). + shelfHeader.titleAction = seeAllAction; + } + else { + // Legacy headers show "See All" textual button on trailing edge. + shelfHeader.accessoryAction = seeAllAction; + } +} +/** + * Update the shelf header to use the provided seeAll action. + * @param objectGraph The App Store object graph used to check feature flags + * @param shelf The shelf whose header needs updating + * @param seeAllAction The see all action to apply + */ +export function replaceShelfSeeAllAction(objectGraph, shelf, seeAllAction) { + if (objectGraph.featureFlags.isEnabled("shelf_header")) { + if (isSome(shelf.header)) { + replaceShelfHeaderSeeAllAction(objectGraph, shelf.header, seeAllAction); + } + else { + shelf.header = { + titleAction: seeAllAction, + }; + } + } + else { + shelf.seeAllAction = seeAllAction; + } +} +//# sourceMappingURL=editorial-page-chart-shelf-builder.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-breakout-large-collection-shelf-builder.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-breakout-large-collection-shelf-builder.js new file mode 100644 index 0000000..093336d --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-breakout-large-collection-shelf-builder.js @@ -0,0 +1,94 @@ +import * as models from "../../../../api/models"; +import * as serverData from "../../../../foundation/json-parsing/server-data"; +import * as mediaAttributes from "../../../../foundation/media/attributes"; +import * as mediaDataStructure from "../../../../foundation/media/data-structure"; +import * as metricsHelpersImpressions from "../../../metrics/helpers/impressions"; +import * as editorialActionUtil from "../../editorial-action-util"; +import * as editorialDataUtil from "../../editorial-data-util"; +import * as editorialComponentMediaUtil from "../../editorial-page-component-media-util"; +import * as editorialCopyUtil from "../../editorial-page-editorial-copy-util"; +import * as editorialOverlayContentUtil from "../../editorial-page-overlay-content-util"; +import { createShelfTokenUrlIfNecessary, shouldDefer } from "./editorial-page-collection-shelf-common"; +import { deepLinkUrlFromData } from "../../../linking/external-deep-link"; +import { isMediaDark } from "../../editorial-media-util"; +import { insertPlaceholdersIntoShelfIfRequired } from "../../../placeholders/placeholders"; +export function buildBreakoutLargeShelf(objectGraph, shelfToken) { + const items = []; + const shelf = new models.Shelf("largeHeroBreakout"); + shelf.isHorizontal = mediaAttributes.attributeAsString(shelfToken.data, "layoutDirection") === "Horizontal"; + const shelfContents = editorialDataUtil.extractRemainingItemsOrInitialShelfContents(objectGraph, shelfToken); + for (const itemData of shelfContents) { + const primaryItemData = editorialDataUtil.extractHydratedPrimaryContentData(objectGraph, itemData); + if ((editorialDataUtil.requiresPrimaryContent(objectGraph, itemData) && + !mediaAttributes.hasAttributes(primaryItemData)) || + shouldDefer(shelfToken)) { + shelfToken.isDeferring = true; + shelfToken.remainingItems.push(itemData); + continue; + } + const metricsOptions = { + targetType: "largeBreakout", + pageInformation: shelfToken.metricsPageInformation, + locationTracker: shelfToken.metricsLocationTracker, + recoMetricsData: mediaDataStructure.metricsFromMediaApiObject(itemData), + }; + const editorialClientParams = editorialDataUtil.extractEditorialClientParams(objectGraph, itemData); + const hideEditorialMedia = serverData.asBooleanOrFalse(editorialClientParams.hideEditorialMedia); + const mediaData = !hideEditorialMedia + ? editorialComponentMediaUtil.editorialMediaDataFromData(objectGraph, itemData, shelfToken.collectionDisplayStyle) + : null; + const lockupOptions = { + metricsOptions, + clientIdentifierOverride: shelfToken.clientIdentifierOverride, + artworkUseCase: 0 /* content.ArtworkUseCase.Default */, + offerEnvironment: "lightOverArtwork", + canDisplayArcadeOfferButton: true, + externalDeepLinkUrl: deepLinkUrlFromData(objectGraph, itemData), + }; + const overlayContent = editorialOverlayContentUtil.extractOverlayContent(objectGraph, itemData, lockupOptions); + if (serverData.isNullOrEmpty(mediaData) && serverData.isNullOrEmpty(overlayContent.collectionIcons)) { + continue; + } + const badgeText = editorialCopyUtil.editorialBadgeFromData(objectGraph, itemData, shelfToken.collectionDisplayStyle); + const badgeType = serverData.isDefinedNonNull(badgeText) + ? { type: "text", title: badgeText } + : { type: "none", title: null }; + const largeBreakoutDetails = new models.BreakoutDetails(editorialCopyUtil.editorialTitleFromData(objectGraph, itemData, shelfToken.collectionDisplayStyle), editorialCopyUtil.editorialDescriptionFromData(objectGraph, itemData, true), badgeType, null); + const largeBreakout = new models.LargeHeroBreakout(largeBreakoutDetails, { position: "leading", wantsBlur: true }, null, mediaData === null || mediaData === void 0 ? void 0 : mediaData.artwork, mediaData === null || mediaData === void 0 ? void 0 : mediaData.video, overlayContent.collectionIcons, mediaData === null || mediaData === void 0 ? void 0 : mediaData.backgroundColor); + largeBreakout.rtlArtwork = mediaData === null || mediaData === void 0 ? void 0 : mediaData.rtlArtwork; + largeBreakout.rtlVideo = mediaData === null || mediaData === void 0 ? void 0 : mediaData.rtlVideo; + largeBreakout.rtlBackgroundColor = mediaData === null || mediaData === void 0 ? void 0 : mediaData.rtlBackgroundColor; + // Configure impressions + const contentMetricsOptions = { + ...metricsOptions, + id: itemData.id, + idType: "its_contentId", + }; + const impressionOptions = metricsHelpersImpressions.impressionOptions(objectGraph, itemData, largeBreakout.details.title, contentMetricsOptions); + metricsHelpersImpressions.addImpressionFields(objectGraph, largeBreakout, impressionOptions); + const breakoutAction = editorialActionUtil.createPrimaryActionForComponentFromData(objectGraph, itemData, shelfToken); + if (serverData.isDefinedNonNull(breakoutAction)) { + breakoutAction.title = editorialCopyUtil.editorialCallToActionFromData(objectGraph, itemData); + } + largeBreakout.details.callToActionButtonAction = breakoutAction; + largeBreakout.clickAction = breakoutAction; + largeBreakout.editorialDisplayOptions = + editorialDataUtil.editorialDisplayOptionsFromClientParams(editorialClientParams); + largeBreakout.lockup = overlayContent.lockup; + largeBreakout.isMediaDark = isMediaDark(objectGraph, mediaData); + largeBreakout.isRTLMediaDark = isMediaDark(objectGraph, mediaData, true); + items.push(largeBreakout); + } + // We don't need this in our incomplete shelf URL, so we'll preemptively remove it. + delete shelfToken.maxItemCount; + shelf.eyebrow = shelfToken.eyebrow; + shelf.eyebrowArtwork = shelfToken.eyebrowArtwork; + shelf.title = shelfToken.title; + shelf.subtitle = shelfToken.subtitle; + shelf.items = items; + shelf.rowsPerColumn = mediaAttributes.attributeAsNumber(shelfToken.data, "rowCount"); + shelf.url = createShelfTokenUrlIfNecessary(objectGraph, shelf, shelfToken); + insertPlaceholdersIntoShelfIfRequired(objectGraph, shelf, shelfToken); + return shelf; +} +//# sourceMappingURL=editorial-page-breakout-large-collection-shelf-builder.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-brick-collection-shelf-builder.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-brick-collection-shelf-builder.js new file mode 100644 index 0000000..cefe63e --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-brick-collection-shelf-builder.js @@ -0,0 +1,146 @@ +import { isNothing, isSome } from "@jet/environment/types/optional"; +import * as models from "../../../../api/models"; +import * as serverData from "../../../../foundation/json-parsing/server-data"; +import * as mediaAttributes from "../../../../foundation/media/attributes"; +import * as mediaDataStructure from "../../../../foundation/media/data-structure"; +import * as content from "../../../content/content"; +import * as metricsHelpersImpressions from "../../../metrics/helpers/impressions"; +import * as metricsHelpersLocation from "../../../metrics/helpers/location"; +import * as editorialActionUtil from "../../editorial-action-util"; +import * as editorialDataUtil from "../../editorial-data-util"; +import * as editorialMediaUtil from "../../editorial-page-component-media-util"; +import * as editorialCopyUtil from "../../editorial-page-editorial-copy-util"; +import { CollectionShelfDisplayStyle } from "../../editorial-page-types"; +import { createShelfTokenUrlIfNecessary, shouldDefer } from "./editorial-page-collection-shelf-common"; +import { deepLinkUrlFromData } from "../../../linking/external-deep-link"; +import { isMediaDark } from "../../editorial-media-util"; +import { insertPlaceholdersIntoShelfIfRequired } from "../../../placeholders/placeholders"; +import { convertToShelfModel, makeShelfId, } from "../../../../gameservicesui/src/editorial-page/editorial-component-builder"; +import { createSmallBrickFromData } from "../../../../gameservicesui/src/models/cards/small-brick"; +export function buildBrickSmallShelf(objectGraph, shelfToken) { + return buildBrickShelf(objectGraph, shelfToken, CollectionShelfDisplayStyle.BrickSmall, "smallBrick"); +} +export function buildBrickMediumShelf(objectGraph, shelfToken) { + return buildBrickShelf(objectGraph, shelfToken, CollectionShelfDisplayStyle.BrickMedium, "brick"); +} +export function buildBrickLargeShelf(objectGraph, shelfToken) { + return buildBrickShelf(objectGraph, shelfToken, CollectionShelfDisplayStyle.BrickLarge, "largeBrick"); +} +// region Brick Creation +function buildBrickShelf(objectGraph, shelfToken, displayStyle, brickComponentType) { + const items = []; + const shelf = new models.Shelf(brickComponentType); + shelf.isHorizontal = mediaAttributes.attributeAsString(shelfToken.data, "layoutDirection") === "Horizontal"; + const shelfContents = editorialDataUtil.extractRemainingItemsOrInitialShelfContents(objectGraph, shelfToken); + for (const itemData of shelfContents) { + const metricsOptions = { + ...shelfToken.metricsImpressionOptions, + targetType: editorialActionUtil.clickTargetForCollectionDisplayStyle(objectGraph, displayStyle), + recoMetricsData: mediaDataStructure.metricsFromMediaApiObject(itemData), + }; + if (!itemData.attributes || shouldDefer(shelfToken)) { + shelfToken.remainingItems.push(itemData); + shelfToken.isDeferring = true; + continue; + } + if (preprocessor.GAMES_TARGET && displayStyle === CollectionShelfDisplayStyle.BrickSmall) { + const clickAction = editorialActionUtil.createPrimaryActionForComponentFromData(objectGraph, itemData, shelfToken); + const smallBrick = createSmallBrickFromData(objectGraph, itemData, makeShelfId(shelfToken), clickAction, {}, {}, true); + if (isNothing(smallBrick)) { + continue; + } + items.push(convertToShelfModel(smallBrick)); + } + else { + const brick = buildBrick(objectGraph, itemData, shelfToken.collectionDisplayStyle, metricsOptions, metricsOptions, shelfToken.clientIdentifierOverride); + brick.clickAction = editorialActionUtil.createPrimaryActionForComponentFromData(objectGraph, itemData, shelfToken); + if (!brick.isValid()) { + continue; + } + items.push(brick); + } + metricsHelpersLocation.nextPosition(shelfToken.metricsImpressionOptions.locationTracker); + } + if (serverData.isDefinedNonNull(shelfToken.presentationHints)) { + shelf.presentationHints = shelfToken.presentationHints; + } + // We don't need this in our incomplete shelf URL, so we'll preemptively remove it. + delete shelfToken.maxItemCount; + shelf.eyebrow = shelfToken.eyebrow; + shelf.eyebrowArtwork = shelfToken.eyebrowArtwork; + shelf.title = shelfToken.title; + shelf.subtitle = shelfToken.subtitle; + shelf.items = items; + shelf.rowsPerColumn = mediaAttributes.attributeAsNumber(shelfToken.data, "rowCount"); + shelf.url = createShelfTokenUrlIfNecessary(objectGraph, shelf, shelfToken); + insertPlaceholdersIntoShelfIfRequired(objectGraph, shelf, shelfToken); + return shelf; +} +/** + * Creates a Brick from the input data. + * Note: the clickAction will need to be assigned post-creation. + * + * @param objectGraph Current object graph + * @param data The data for the Brick + * @param collectionDisplayStyle The desired display style for the brick + * @param metricsOptions Metrics options for impressions + * @param lockupMetricsOptions Metrics options for the collection icon lockups + * @param clientIdentifierOverride Any preferred client identifier override + * @returns A built Brick object + */ +export function buildBrick(objectGraph, data, collectionDisplayStyle, metricsOptions, lockupMetricsOptions, clientIdentifierOverride) { + const brick = new models.Brick(); + const editorialClientParams = editorialDataUtil.extractEditorialClientParams(objectGraph, data); + const hideEditorialMedia = serverData.asBooleanOrFalse(editorialClientParams.hideEditorialMedia); + if (!hideEditorialMedia) { + const editorialMediaData = editorialMediaUtil.editorialMediaDataFromData(objectGraph, data, collectionDisplayStyle); + if (isSome(editorialMediaData === null || editorialMediaData === void 0 ? void 0 : editorialMediaData.artwork)) { + brick.artworks = [editorialMediaData.artwork]; + brick.isMediaDark = isMediaDark(objectGraph, editorialMediaData); + } + if (isSome(editorialMediaData === null || editorialMediaData === void 0 ? void 0 : editorialMediaData.rtlArtwork)) { + brick.rtlArtwork = editorialMediaData === null || editorialMediaData === void 0 ? void 0 : editorialMediaData.rtlArtwork; + brick.isRTLMediaDark = isMediaDark(objectGraph, editorialMediaData, true); + } + } + const lockupOptions = { + metricsOptions: lockupMetricsOptions, + clientIdentifierOverride: clientIdentifierOverride, + artworkUseCase: 0 /* content.ArtworkUseCase.Default */, + canDisplayArcadeOfferButton: true, + externalDeepLinkUrl: deepLinkUrlFromData(objectGraph, data), + }; + metricsHelpersLocation.pushBasicLocation(objectGraph, lockupOptions.metricsOptions, "collectionIcons"); + brick.collectionIcons = editorialMediaUtil.editorialFallbackAppIconsFromData(objectGraph, data, lockupOptions); + metricsHelpersLocation.popLocation(lockupOptions.metricsOptions.locationTracker); + if (serverData.isNullOrEmpty(brick.collectionIcons)) { + const primaryAppIcon = content.iconFromData(objectGraph, data, { + useCase: 0 /* content.ArtworkUseCase.Default */, + }); + if (serverData.isDefinedNonNullNonEmpty(primaryAppIcon)) { + brick.collectionIcons = [primaryAppIcon]; + } + } + brick.caption = editorialCopyUtil.editorialBadgeFromData(objectGraph, data, collectionDisplayStyle); + brick.title = editorialCopyUtil.editorialTitleFromData(objectGraph, data, collectionDisplayStyle); + brick.subtitle = editorialCopyUtil.editorialDescriptionFromData(objectGraph, data); + brick.accessibilityLabel = brick.title; + brick.editorialDisplayOptions = editorialDataUtil.editorialDisplayOptionsFromClientParams(editorialClientParams); + // Configure impressions + const metricsIdType = serverData.isDefinedNonNullNonEmpty(brick.artworks) + ? "its_contentId" + : "collection_id"; + const contentMetricsOptions = { + ...metricsOptions, + id: data.id, + idType: metricsIdType, + }; + const impressionOptions = metricsHelpersImpressions.impressionOptions(objectGraph, data, brick.title, contentMetricsOptions); + metricsHelpersImpressions.addImpressionFields(objectGraph, brick, impressionOptions); + // Safe area + brick.artworkSafeArea = models.ChartOrCategorySafeArea.defaultTileArtworkSafeArea; + brick.textSafeArea = models.ChartOrCategorySafeArea.defaultTileTextSafeArea; + return brick; +} +// endregion +//# sourceMappingURL=editorial-page-brick-collection-shelf-builder.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-collection-shelf-common.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-collection-shelf-common.js new file mode 100644 index 0000000..5af39c4 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-collection-shelf-common.js @@ -0,0 +1,248 @@ +import { buildEditorialShelf } from ".."; +import * as models from "../../../../api/models"; +import * as serverData from "../../../../foundation/json-parsing/server-data"; +import { Parameters, Path, Protocol } from "../../../../foundation/network/url-constants"; +import * as urls from "../../../../foundation/network/urls"; +import * as mediaUrlMapping from "../../../builders/url-mapping"; +import * as metricsHelpersClicks from "../../../metrics/helpers/clicks"; +import * as metricsHelpersLocation from "../../../metrics/helpers/location"; +import { createLocationTrackerCopy, setCurrentPosition } from "../../../metrics/helpers/location"; +import * as placeholders from "../../../placeholders/placeholders"; +import { createBaseShelfToken } from "../../editorial-page-shelf-token"; +import { collectionDisplayStyleOverride, CollectionShelfDisplayStyle, CollectionShelfFilterOverride, EditorialShelfType, } from "../../editorial-page-types"; +import { isNothing, isSome } from "@jet/environment"; +import * as gamesComponentBuilder from "../../../../gameservicesui/src/editorial-page/editorial-component-builder"; +import { makeEditorialShelfCollectionPageIntent } from "../../../../api/intents/editorial/editorial-shelf-collection-page-intent"; +import { makeEditorialShelfCollectionPageURL } from "../../editorial-shelf-collection-page-utils"; +import { getLocale } from "../../../locale"; +import { getPlatform } from "../../../preview-platform"; +import { collectionShelfDisplayStyleFromShelfData } from "../../editorial-data-util"; +// region Shelf Tokens +/** + * Whether we should defer building the rest of a shelf given a shelf token + * @param token + */ +export function shouldDefer(token) { + return token && token.isDeferring && token.isFirstRender; +} +// endregion +// region Shelf Urls +/** + * Configure `url` on a standard editorial page shelf if it needs to fetch more content. + * @param objectGraph + * @param shelf The shelf we'll be adding the url to + * @param shelfToken Token to encode in URL for subsequent fetch. + */ +export function createShelfTokenUrlIfNecessary(objectGraph, shelf, shelfToken) { + if (serverData.isNullOrEmpty(shelfToken)) { + return null; + } + if (objectGraph.client.isWeb) { + return null; + } + const shouldAddFirstRenderUrl = shelfToken.remainingItems.length || shelfToken.recommendationsHref || shelfToken.onDeviceRecommendationsUseCase; + if (shouldAddFirstRenderUrl && shelfToken.isFirstRender) { + return editorialPageShelfUrl(shelfToken); + } + else { + return null; + } +} +/** + * Updates a shelf URL based on the provided token. + * @param objectGraph Current object graph + * @param shelf Shelf to add url to. + * @param token Token to encode in the url. + */ +function updateShelfTokenUrlWithNewShelfToken(objectGraph, shelf, shelfToken) { + const originalShelfUrl = urls.URL.from(shelf.url); + const updatedUrl = urls.URL.from(createShelfTokenUrlIfNecessary(objectGraph, shelf, shelfToken)); + // Add missing query params to the updated URL from the original. + for (const key of Object.keys(originalShelfUrl.query)) { + if (serverData.isNull(updatedUrl.query[key])) { + updatedUrl.query[key] = originalShelfUrl.query[key]; + } + } + // Finally, update the shelf's URL. + shelf.url = updatedUrl.build(); +} +/** + * Stores the impression metrics for a placeholder shelf in the shelf token. + * @param objectGraph Current object graph + * @param shelf The shelf + * @param shelfToken The shelf token + */ +export function storePlaceholderShelfImpressionMetrics(objectGraph, shelf, shelfToken) { + if (isNothing(shelf.url) || isNothing(shelf.impressionMetrics) || !shelfToken.showingPlaceholders) { + return; + } + const originalShelfUrlString = shelf.url; + try { + // Extract the token from the URL. + // Note: Although we have access to the shelfToken here, we do not know that + // the url was constructed from token in its current state. To be safe, + // if not efficient, we reverse engineer the URL to get the token. + const originalShelfUrl = urls.URL.from(originalShelfUrlString); + const encodedToken = originalShelfUrl.query[Parameters.token]; + const shelfTokenFromUrl = JSON.parse(decodeURIComponent(encodedToken)); + // Modify the token to include the impressions metrics. + shelfTokenFromUrl.originalPlaceholderShelfImpressionMetrics = shelf.impressionMetrics; + updateShelfTokenUrlWithNewShelfToken(objectGraph, shelf, shelfTokenFromUrl); + } + catch { + shelf.url = originalShelfUrlString; + } +} +/** + * // Merge the original impression metrics with the newly created impression metrics. + * @param objectGraph Current object graph + * @param shelf The hydrated shelf + * @param shelfToken The shelf token + */ +export function mergeShelfImpressionMetricsWithPlaceholders(objectGraph, shelf, shelfToken) { + if (serverData.isNullOrEmpty(shelfToken.originalPlaceholderShelfImpressionMetrics)) { + return; + } + // If the `shelf.impressionMetrics` is null, we just defer to the original metrics. + if (serverData.isNull(shelf.impressionMetrics)) { + shelf.impressionMetrics = shelfToken.originalPlaceholderShelfImpressionMetrics; + } + else { + for (const key in shelfToken.originalPlaceholderShelfImpressionMetrics.fields) { + if (Object.prototype.hasOwnProperty.call(shelfToken.originalPlaceholderShelfImpressionMetrics.fields, key)) { + shelf.impressionMetrics.fields[key] = shelfToken.originalPlaceholderShelfImpressionMetrics.fields[key]; + } + } + } +} +/** + * Configure `url` on a standard editorial page shelf if it needs to fetch more content. + * @param objectGraph + * @param shelf The shelf we'll be adding the url to + * @param shelfToken Token to encode in URL for subsequent fetch. + */ +export function createShelfSeeAllActionIfNecessary(objectGraph, shelf, shelfToken) { + if (serverData.isNullOrEmpty(shelfToken) || serverData.isNullOrEmpty(shelf)) { + return null; + } + if (shouldShowSeeAll(shelfToken)) { + const action = new models.FlowAction("page"); + // The web client makes a separate request for See All pages, so we don't sidepack for web. + if (!placeholders.isPlaceholderShelf(shelf) && !objectGraph.client.isWeb) { + const contentShelfId = `shelf_${shelfToken.id}`; + action.pageData = createSeeAllPage(objectGraph, shelfToken, shelf.contentType, contentShelfId, isSome(shelfToken.recommendationsHref)); + } + const additionalPageUrlQueryParams = {}; + if (shelfToken.type === EditorialShelfType.Recommendations) { + additionalPageUrlQueryParams[Parameters.editorialPageId] = shelfToken.pageId; + } + if (objectGraph.client.isWeb) { + const destinationIntent = makeEditorialShelfCollectionPageIntent({ + ...getLocale(objectGraph), + ...getPlatform(objectGraph), + id: shelfToken.id, + }); + action.destination = destinationIntent; + action.pageUrl = makeEditorialShelfCollectionPageURL(objectGraph, destinationIntent); + } + else { + action.pageUrl = mediaUrlMapping.hrefToRoutableUrl(objectGraph, shelfToken.data.href, additionalPageUrlQueryParams); + } + action.title = objectGraph.loc.string("ACTION_SEE_ALL"); + action.referrerUrl = shelfToken.metricsPageInformation.pageUrl; + // This can be called after we've gone through and added items to a shelf, meaning the locationPosition + // would have been incremented to the number of shelf items, the see all should always have a position of + // 0 so we reset it here and use that, without mucking with the active location tracker. + const resetLocationTracker = createLocationTrackerCopy(shelfToken.metricsLocationTracker); + setCurrentPosition(resetLocationTracker, 0); + metricsHelpersClicks.addClickEventToSeeAllAction(objectGraph, action, shelfToken.seeAllUrl, { + pageInformation: shelfToken.metricsPageInformation, + locationTracker: resetLocationTracker, + }); + return action; + } + else { + return null; + } +} +/** + * Determine whether lockup shelves should show "See All" on given platforms. + * + * @param shelfToken Token to encode in URL for subsequent fetch. + * @return Whether or not a lockup shelf with given properties should have a "See All" action. + */ +export function shouldShowSeeAll(shelfToken) { + if (shelfToken.isSeeAll) { + return false; + } + switch (shelfToken.collectionDisplayStyle) { + case CollectionShelfDisplayStyle.BreakoutLarge: + case CollectionShelfDisplayStyle.Poster: + return false; + default: + break; + } + // On all other platforms, we always to attach "See All", except AppStore_ComingSoon, + // which should not because the see all page won't drop lockups whose pre-order has + // been released (which the AppStore_ComingSoon swoosh will). + // + // The Games app is able to show the see all irrespective of the preorder flag. + return (!shelfToken.filterOverrides.includes(CollectionShelfFilterOverride.ShowOnlyPreorder) || + preprocessor.GAMES_TARGET); +} +/** + * Returns the URL schema for editorial page shelves that may need to fetch additional content. + * Editorial-Page-Related builders can extend on this scheme if needed, e.g. query param on Continue Playing shelves. + * @param shelfToken Token to encode in URL for subsequent fetch. + * @param parseContext + */ +export function editorialPageShelfUrl(shelfToken) { + const shelfUrl = new urls.URL() + .set("protocol", Protocol.internal) + .append("pathname", Path.editorialPage) + .append("pathname", Path.shelf) + .param(Parameters.token, encodeURIComponent(JSON.stringify(shelfToken))); + return shelfUrl.build(); +} +/** + * Creates a page that can be used for side-packing see all pages into a room. + * + * @param objectGraph + * @param {EditorialPageShelfToken} shelfToken The shelf token used to build the original shelf + * @param {ShelfContentType} preferredShelfContentType The content type to use for the page + * @param {string} parentShelfId The ID of the parent shelf that the contains the sidepack items + * @returns {GenericPage} A GenericPage which will use the parentShelfItems from the see all to render the initial room + */ +export function createSeeAllPage(objectGraph, shelfToken, preferredShelfContentType, parentShelfId, isComplete) { + // Create a new shelf token with a new location tracker in order to get accurate metrics for the items in the shelf. + const newLocationTracker = metricsHelpersLocation.newLocationTracker(); + const collectionDisplayStyle = collectionShelfDisplayStyleFromShelfData(objectGraph, shelfToken.data); + const newToken = createBaseShelfToken(objectGraph, shelfToken.pageId, shelfToken.data, shelfToken.isArcadePage, shelfToken.shelfIndex, shelfToken.metricsPageInformation, newLocationTracker, true, collectionDisplayStyleOverride(collectionDisplayStyle)); + const contentShelf = buildEditorialShelf(objectGraph, undefined, newToken); + if (contentShelf === null) { + return null; + } + contentShelf.title = null; + contentShelf.eyebrow = null; + contentShelf.isHorizontal = false; + contentShelf.id = parentShelfId; + let pageHeader; + if (preprocessor.GAMES_TARGET) { + pageHeader = gamesComponentBuilder.makeGamesPageHeader(shelfToken, shelfToken.title, contentShelf.items, shelfToken.subtitle); + } + else { + pageHeader = new models.PageHeader(null, shelfToken.title, null); + } + const headerShelf = new models.Shelf("pageHeader"); + headerShelf.id = "shelf_page_header"; + headerShelf.items = [pageHeader]; + const shelves = [headerShelf, contentShelf]; + const page = new models.GenericPage(shelves); + page.isIncomplete = !(isComplete !== null && isComplete !== void 0 ? isComplete : false); + if (isNothing(page.pageMetrics.pageFields)) { + page.pageMetrics.pageFields = {}; + } + return page; +} +// endregion +//# sourceMappingURL=editorial-page-collection-shelf-common.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-hero-collection-shelf-builder.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-hero-collection-shelf-builder.js new file mode 100644 index 0000000..adc7087 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-hero-collection-shelf-builder.js @@ -0,0 +1,137 @@ +import * as models from "../../../../api/models"; +import * as serverData from "../../../../foundation/json-parsing/server-data"; +import * as mediaAttributes from "../../../../foundation/media/attributes"; +import * as mediaDataStructure from "../../../../foundation/media/data-structure"; +import { shallowCopyOf } from "../../../../foundation/util/objects"; +import * as breakoutsCommon from "../../../arcade/breakouts-common"; +import * as contentAttributes from "../../../content/attributes"; +import * as metricsHelpersImpressions from "../../../metrics/helpers/impressions"; +import * as metricsHelpersLocation from "../../../metrics/helpers/location"; +import * as article from "../../../today/article"; +import * as editorialDataUtil from "../../editorial-data-util"; +import * as editorialMediaUtil from "../../editorial-media-util"; +import { editorialTitleFromData } from "../../editorial-page-editorial-copy-util"; +import { heroOverlayFromData } from "../../editorial-page-hero-util"; +import * as editorialOverlayContentUtil from "../../editorial-page-overlay-content-util"; +import { CollectionShelfDisplayStyle } from "../../editorial-page-types"; +import { createShelfTokenUrlIfNecessary, shouldDefer } from "./editorial-page-collection-shelf-common"; +export function buildHeroShelf(objectGraph, shelfToken) { + if (shelfToken.shelfIndex !== 0) { + return null; + } + const shelf = new models.Shelf("heroCarousel"); + const heroCarousel = new models.HeroCarousel(); + heroCarousel.autoScrollConfiguration = heroAutoscrollConfiguration(objectGraph); + const shelfContents = editorialDataUtil.extractRemainingItemsOrInitialShelfContents(objectGraph, shelfToken); + for (const itemData of shelfContents) { + const primaryItemData = editorialDataUtil.extractHydratedPrimaryContentData(objectGraph, itemData); + if ((editorialDataUtil.requiresPrimaryContent(objectGraph, itemData) && + !mediaAttributes.hasAttributes(primaryItemData)) || + shouldDefer(shelfToken)) { + shelfToken.isDeferring = true; + shelfToken.remainingItems.push(itemData); + continue; + } + const heroCarouselItemMetricsOptions = { + ...shelfToken.metricsImpressionOptions, + idType: "its_contentId", + targetType: "hero", + pageInformation: shelfToken.metricsPageInformation, + locationTracker: shelfToken.metricsLocationTracker, + recoMetricsData: mediaDataStructure.metricsFromMediaApiObject(itemData), + }; + const heroMediaData = editorialMediaUtil.editorialMediaDataForPlacement(objectGraph, itemData, editorialMediaUtil.EditorialMediaPlacement.Hero); + const lockupOptions = { + metricsOptions: heroCarouselItemMetricsOptions, + clientIdentifierOverride: shelfToken.clientIdentifierOverride, + artworkUseCase: 0 /* content.ArtworkUseCase.Default */, + offerEnvironment: "lightOverArtwork", + canDisplayArcadeOfferButton: true, + }; + const overlayContent = editorialOverlayContentUtil.extractOverlayContent(objectGraph, itemData, lockupOptions); + const heroCarouselItem = new models.HeroCarouselItem(); + const productData = article.productDataFromArticle(objectGraph, itemData); + const metricsTitle = editorialTitleFromData(objectGraph, itemData, CollectionShelfDisplayStyle.Hero); + const heroCarouselItemImpressionOptions = metricsHelpersImpressions.impressionOptions(objectGraph, itemData, metricsTitle, heroCarouselItemMetricsOptions); + heroCarouselItemImpressionOptions.isPreorder = contentAttributes.contentAttributeAsBooleanOrFalse(objectGraph, productData, "isPreorder"); + metricsHelpersImpressions.addImpressionFields(objectGraph, heroCarouselItem, heroCarouselItemImpressionOptions); + // Push the heroCarouselItem here so that the click action has the item in its location + // but we do not want to add it to the overall location tracker, so pop it right after adding it to the button + // actiono + // <rdar://problem/60883269> Metrics: Arcade: Container values requested in Location field + metricsHelpersLocation.pushContentLocation(objectGraph, heroCarouselItemImpressionOptions, metricsTitle); + const editorialClientParams = editorialDataUtil.extractEditorialClientParams(objectGraph, itemData); + const hideEditorialMedia = serverData.asBooleanOrFalse(editorialClientParams.hideEditorialMedia); + heroCarouselItem.overlay = heroOverlayFromData(objectGraph, itemData, shelfToken, editorialClientParams); + heroCarouselItem.collectionIcons = overlayContent.collectionIcons; + heroCarouselItem.editorialDisplayOptions = + editorialDataUtil.editorialDisplayOptionsFromClientParams(editorialClientParams); + populateHeroCarouselItemMedia(objectGraph, heroCarouselItem, hideEditorialMedia, heroMediaData, false); + if (heroCarouselItem.isValid()) { + heroCarousel.items.push(heroCarouselItem); + } + const rtlHeroCarouselItem = shallowCopyOf(heroCarouselItem); + populateHeroCarouselItemMedia(objectGraph, rtlHeroCarouselItem, hideEditorialMedia, heroMediaData, true); + if (rtlHeroCarouselItem.isValid()) { + heroCarousel.rtlItems.push(rtlHeroCarouselItem); + } + metricsHelpersLocation.popLocation(heroCarouselItemImpressionOptions.locationTracker); + metricsHelpersLocation.nextPosition(heroCarouselItemImpressionOptions.locationTracker); + } + // We don't need this in our incomplete shelf URL, so we'll preemptively remove it. + delete shelfToken.maxItemCount; + shelf.isHorizontal = false; + shelf.eyebrow = shelfToken.eyebrow; + shelf.eyebrowArtwork = shelfToken.eyebrowArtwork; + shelf.title = shelfToken.title; + shelf.subtitle = shelfToken.subtitle; + shelf.items = [heroCarousel]; + shelf.url = createShelfTokenUrlIfNecessary(objectGraph, shelf, shelfToken); + return shelf; +} +/** + * Populates the media properties of a `HeroCarouselItem`. + * @param objectGraph Current object graph + * @param heroCarouselItem The item to populate + * @param hideEditorialMedia Whether to hide editorial media + * @param heroMediaData The `EditorialMediaData` to derive the media properties from + * @param isRTL Whether this item will be used in an RTL layout + */ +function populateHeroCarouselItemMedia(objectGraph, heroCarouselItem, hideEditorialMedia, heroMediaData, isRTL) { + if (!hideEditorialMedia) { + const backgroundColor = isRTL ? heroMediaData === null || heroMediaData === void 0 ? void 0 : heroMediaData.rtlBackgroundColor : heroMediaData === null || heroMediaData === void 0 ? void 0 : heroMediaData.backgroundColor; + heroCarouselItem.backgroundColor = backgroundColor; + const artworkData = isRTL ? heroMediaData === null || heroMediaData === void 0 ? void 0 : heroMediaData.rtlArtworkData : heroMediaData === null || heroMediaData === void 0 ? void 0 : heroMediaData.artworkData; + if (!objectGraph.client.isMac || objectGraph.props.isNotEnabled("macOSArcadeHeaderUpdates")) { + heroCarouselItem.titleEffect = breakoutsCommon.titleEffectFromArtwork(objectGraph, artworkData); + } + const artwork = isRTL ? heroMediaData === null || heroMediaData === void 0 ? void 0 : heroMediaData.rtlArtwork : heroMediaData === null || heroMediaData === void 0 ? void 0 : heroMediaData.artwork; + heroCarouselItem.artwork = artwork; + const video = isRTL ? heroMediaData === null || heroMediaData === void 0 ? void 0 : heroMediaData.rtlVideo : heroMediaData === null || heroMediaData === void 0 ? void 0 : heroMediaData.video; + heroCarouselItem.video = video; + } + heroCarouselItem.isMediaDark = editorialMediaUtil.isMediaDark(objectGraph, heroMediaData, isRTL); +} +/** + * Generates the auto scroll configuration for the hero carousel + * @param objectGraph Current object graph + * @returns Built auto scroll configuration + */ +export function heroAutoscrollConfiguration(objectGraph) { + return { + isAutoScrollEnabled: objectGraph.bag.heroCarouselAutoScrollDuration > 0.0, + autoScrollInterval: objectGraph.bag.heroCarouselAutoScrollDuration, + }; +} +/** + * Decorates the input shelf metrics options with shelf specific fields. + * @param objectGraph Current object graph + * @param shelfMetricsOptions Base shelf metrics options + * @returns Decorated shelf metrics options + */ +export function decorateHeroShelfMetricsOptions(objectGraph, shelfMetricsOptions) { + shelfMetricsOptions.title = "heroCarousel"; + const autoScrollConfiguration = heroAutoscrollConfiguration(objectGraph); + shelfMetricsOptions.autoAdvanceInterval = autoScrollConfiguration.autoScrollInterval; +} +//# sourceMappingURL=editorial-page-hero-collection-shelf-builder.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-lockup-collection-shelf-builder.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-lockup-collection-shelf-builder.js new file mode 100644 index 0000000..12525c4 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-lockup-collection-shelf-builder.js @@ -0,0 +1,193 @@ +import { isSome } from "@jet/environment"; +import * as models from "../../../../api/models"; +import * as serverData from "../../../../foundation/json-parsing/server-data"; +import * as mediaAttributes from "../../../../foundation/media/attributes"; +import * as filtering from "../../../filtering"; +import * as metricsHelpersLocation from "../../../metrics/helpers/location"; +import { insertPlaceholdersIntoShelfIfRequired } from "../../../placeholders/placeholders"; +import * as editorialDataUtil from "../../editorial-data-util"; +import { lockupFromData } from "../../editorial-page-lockup-utils"; +import { CollectionShelfDisplayStyle, CollectionShelfFilterOverride, collectionShelfLayoutDirection, CollectionShelfLayoutDirection, displayLimitForCollectionShelf, } from "../../editorial-page-types"; +import { createShelfTokenUrlIfNecessary, shouldDefer } from "./editorial-page-collection-shelf-common"; +import * as gamesComponentBuilder from "../../../../gameservicesui/src/editorial-page/editorial-component-builder"; +import * as charts from "../../../../gameservicesui/src/utility/charts"; +import { arcadeColor } from "../../../arcade/arcade-common"; +import { artworkTemplateForBundleImage, createArtworkForResource } from "../../../content/artwork/artwork"; +export function buildEditorialLockupHierarchicalPortrait(objectGraph, shelfToken) { + return buildLockupShelf(objectGraph, shelfToken, CollectionShelfDisplayStyle.EditorialLockupHierarchicalPortrait, "mediumImageLockup", true, CollectionShelfLayoutDirection.Vertical); +} +export function buildEditorialLockupHierarchicalRows(objectGraph, shelfToken) { + return buildLockupShelf(objectGraph, shelfToken, CollectionShelfDisplayStyle.EditorialLockupHierarchicalRows, "mediumImageLockup", true, CollectionShelfLayoutDirection.Vertical); +} +export function buildEditorialLockupMediumShelf(objectGraph, shelfToken) { + return buildLockupShelf(objectGraph, shelfToken, CollectionShelfDisplayStyle.EditorialLockupMedium, "mediumImageLockup"); +} +export function buildEditorialLockupMediumVariantShelf(objectGraph, shelfToken) { + return buildLockupShelf(objectGraph, shelfToken, CollectionShelfDisplayStyle.EditorialLockupMediumVariant, "mediumImageLockup"); +} +export function buildEditorialLockupLargeShelf(objectGraph, shelfToken) { + return buildLockupShelf(objectGraph, shelfToken, CollectionShelfDisplayStyle.EditorialLockupLarge, "largeImageLockup"); +} +export function buildEditorialLockupLargeVariantShelf(objectGraph, shelfToken) { + return buildLockupShelf(objectGraph, shelfToken, CollectionShelfDisplayStyle.EditorialLockupLargeVariant, "largeImageLockup"); +} +export function buildLockupChartShelf(objectGraph, shelfToken) { + return buildLockupShelf(objectGraph, shelfToken, CollectionShelfDisplayStyle.Charts, shelfToken.isSeeAll ? "smallLockup" : "mediumImageLockup", true, CollectionShelfLayoutDirection.Vertical); +} +export function buildLockupMedium(objectGraph, shelfToken) { + shelfToken.metricsImpressionOptions.shouldOmitImpressionIndex = true; + return buildLockupShelf(objectGraph, shelfToken, CollectionShelfDisplayStyle.LockupMedium, "mediumLockup"); +} +export function buildLockupSmallShelf(objectGraph, shelfToken, insertPlaceholdersIfRequired = true, overrideShelfLayoutDirection) { + if (objectGraph.featureFlags.isEnabled("force_display_lockup_ordinals")) { + // For 2023F Charts testing before server is ready. Can be removed in the 2024A timeline. + shelfToken.showOrdinals = true; + } + return buildLockupShelf(objectGraph, shelfToken, CollectionShelfDisplayStyle.LockupSmall, "smallLockup", insertPlaceholdersIfRequired, overrideShelfLayoutDirection); +} +export function buildLockupLargeShelf(objectGraph, shelfToken, insertPlaceholdersIfRequired = true) { + return buildLockupShelf(objectGraph, shelfToken, CollectionShelfDisplayStyle.LockupLarge, "largeLockup", insertPlaceholdersIfRequired); +} +export function buildEditorialLockupPosterShelf(objectGraph, shelfToken) { + const shelf = buildLockupShelf(objectGraph, shelfToken, CollectionShelfDisplayStyle.Poster, "posterLockup"); + if (isSome(shelf)) { + shelf.horizontalScrollTargetBehavior = models.ShelfHorizontalScrollTargetBehavior.CenterAligned; + } + return shelf; +} +// region Lockup Creation +function buildLockupShelf(objectGraph, shelfToken, displayStyle, lockupComponentType, insertPlaceholdersIfRequired = true, overrideShelfLayoutDirection) { + const items = []; + const shelf = new models.Shelf(lockupComponentType); + const layoutDirection = overrideShelfLayoutDirection !== null && overrideShelfLayoutDirection !== void 0 ? overrideShelfLayoutDirection : collectionShelfLayoutDirection(shelfToken); + shelf.isHorizontal = layoutDirection === CollectionShelfLayoutDirection.Horizontal; + const shelfContents = editorialDataUtil.extractRemainingItemsOrInitialShelfContents(objectGraph, shelfToken); + const displayLimit = displayLimitForCollectionShelf(displayStyle, layoutDirection, shelfToken); + for (const [index, itemData] of shelfContents.entries()) { + // If we encounter a type of app-events, this means they have been incorrectly programmed, + // and we should throw the shelf away. + if (itemData.type === "app-events") { + return null; + } + if (serverData.isNull(itemData.attributes) || shouldDefer(shelfToken)) { + shelfToken.isDeferring = true; + shelfToken.remainingItems.push(itemData); + continue; + } + // Filter out unwanted content + if (filtering.shouldFilter(objectGraph, itemData, 80894 /* filtering.Filter.All */)) { + continue; + } + let lockup = null; + if (preprocessor.GAMES_TARGET && gamesComponentBuilder.shouldUseChartCard(displayStyle, shelfToken)) { + lockup = gamesComponentBuilder.makeChartCard(objectGraph, itemData, shelfToken, index, "Editorial"); + } + else if (preprocessor.GAMES_TARGET && gamesComponentBuilder.shouldUseMediaCard(displayStyle)) { + lockup = gamesComponentBuilder.makeEditorialMediaCard(objectGraph, itemData, "Card", shelfToken, "Editorial"); + } + else if (preprocessor.GAMES_TARGET && gamesComponentBuilder.shouldUseGameLockup(displayStyle)) { + lockup = gamesComponentBuilder.makeGameLockupShelfModel(objectGraph, itemData, shelfToken); + } + else { + lockup = lockupFromData(objectGraph, itemData, shelfToken, items.length, displayStyle); + } + if (lockup) { + items.push(lockup); + metricsHelpersLocation.nextPosition(shelfToken.metricsImpressionOptions.locationTracker); + shelfToken.ordinalIndex++; + if (items.length === displayLimit) { + break; + } + } + } + if (displayStyle === CollectionShelfDisplayStyle.EditorialLockupMediumVariant || + displayStyle === CollectionShelfDisplayStyle.EditorialLockupLargeVariant) { + if (serverData.isNull(shelf.presentationHints)) { + shelf.presentationHints = { showSupplementaryText: true }; + } + else { + shelf.presentationHints = { + ...shelf.presentationHints, + showSupplementaryText: true, + }; + } + } + // We don't need this in our incomplete shelf URL, so we'll preemptively remove it. + delete shelfToken.maxItemCount; + shelf.eyebrow = shelfToken.eyebrow; + shelf.eyebrowArtwork = shelfToken.eyebrowArtwork; + shelf.title = shelfToken.title; + shelf.subtitle = shelfToken.subtitle; + // Hydrate Games data if the eyebrow has not already been populated from the shelf token. + if (preprocessor.GAMES_TARGET && shelf.eyebrow == null && shelf.eyebrowArtwork == null) { + populateGamesHeaderContent(shelf, shelfToken, objectGraph); + } + if (preprocessor.GAMES_TARGET && + gamesComponentBuilder.shouldUseComponentGrid(displayStyle, layoutDirection, shelfToken)) { + const item = gamesComponentBuilder.makeComponentGrid(objectGraph, items, shelfToken, displayStyle); + shelf.items = isSome(item) ? [item] : []; + } + else { + shelf.items = items; + } + shelf.rowsPerColumn = mediaAttributes.attributeAsNumber(shelfToken.data, "rowCount"); + shelf.shouldFilterApps = !shelfToken.filterOverrides.includes(CollectionShelfFilterOverride.ShowInstalled); + shelf.url = createShelfTokenUrlIfNecessary(objectGraph, shelf, shelfToken); + if (insertPlaceholdersIfRequired) { + let placeholderDisplayLimit = displayLimit; + if (isSome(displayLimit) && + displayLimit > 4 && + (displayStyle === CollectionShelfDisplayStyle.Charts || + displayStyle === CollectionShelfDisplayStyle.EditorialLockupMedium)) { + // TODO: Remove this override when this radar is complete: rdar://148395979 ([EditorialPage] Placeholders for Charts and 4UP are not rendering as a ComponentGrid) + placeholderDisplayLimit = 4; + } + insertPlaceholdersIntoShelfIfRequired(objectGraph, shelf, shelfToken, placeholderDisplayLimit); + } + return shelf; +} +/** + * Hydrates game related header data + * + * Note that both the header and non header fields should be hydrated, since header + * preference can be switched off. In this case we will not have the capacity to color the Arcade eyebrow + */ +function populateGamesHeaderContent(shelf, shelfToken, objectGraph) { + switch (serverData.asString(shelfToken.data.attributes, "chart")) { + case "combined-game-center" /* TopChartType.CombinedGameCenter */: + const gameCenterEyebrow = charts.makeChartsTopSubtitle("game-center", objectGraph); + const gameCenterEyebrowArtwork = createArtworkForResource(objectGraph, artworkTemplateForBundleImage("ProductCapabilityGameCenter")); + shelf.eyebrow = gameCenterEyebrow; + shelf.eyebrowArtwork = gameCenterEyebrowArtwork; + shelf.header = { + eyebrow: gameCenterEyebrow, + eyebrowArtwork: gameCenterEyebrowArtwork, + eyebrowArtworkSize: 14, + title: shelfToken.title, + subtitle: shelfToken.subtitle, + }; + break; + case "top-arcade" /* TopChartType.TopArcade */: + const color = arcadeColor; + const arcadeEyebrow = charts.makeChartsTopSubtitle("arcade", objectGraph); + shelf.eyebrow = arcadeEyebrow; + shelf.header = { + eyebrow: arcadeEyebrow, + title: shelfToken.title, + subtitle: shelfToken.subtitle, + configuration: { + eyebrowColor: { + type: "rgb", + red: color.red, + green: color.green, + blue: color.blue, + }, + }, + }; + break; + default: + break; + } +} +// endregion +//# sourceMappingURL=editorial-page-lockup-collection-shelf-builder.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-story-card-collection-shelf-builder.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-story-card-collection-shelf-builder.js new file mode 100644 index 0000000..3e78c25 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-story-card-collection-shelf-builder.js @@ -0,0 +1,70 @@ +import * as models from "../../../../api/models"; +import { isNull } from "../../../../foundation/json-parsing/server-data"; +import * as mediaAttributes from "../../../../foundation/media/attributes"; +import * as mediaDataStructure from "../../../../foundation/media/data-structure"; +import * as metricsHelpersLocation from "../../../metrics/helpers/location"; +import { insertPlaceholdersIntoShelfIfRequired } from "../../../placeholders/placeholders"; +import { clickTargetForCollectionDisplayStyle } from "../../editorial-action-util"; +import * as editorialDataUtil from "../../editorial-data-util"; +import * as editorialMediaUtil from "../../editorial-media-util"; +import { CollectionShelfDisplayStyle, collectionShelfLayoutDirection } from "../../editorial-page-types"; +import { createShelfTokenUrlIfNecessary, shouldDefer } from "./editorial-page-collection-shelf-common"; +import { buildStoryCard } from "./editorial-page-story-card-utils"; +import * as gamesComponentBuilder from "../../../../gameservicesui/src/editorial-page/editorial-component-builder"; +import { isSome } from "@jet/environment/types/optional"; +export function buildSmallStoryCardShelf(objectGraph, shelfToken) { + return buildStoryCardShelf(objectGraph, shelfToken, CollectionShelfDisplayStyle.StorySmall, "smallStoryCard"); +} +export function buildMediumStoryCardShelf(objectGraph, shelfToken) { + return buildStoryCardShelf(objectGraph, shelfToken, CollectionShelfDisplayStyle.StoryMedium, "mediumStoryCard"); +} +function buildStoryCardShelf(objectGraph, shelfToken, displayStyle, storyComponentType) { + const items = []; + const shelf = new models.Shelf(storyComponentType); + const layoutDirection = collectionShelfLayoutDirection(shelfToken); + shelf.isHorizontal = layoutDirection === "Horizontal"; + const shelfContents = editorialDataUtil.extractRemainingItemsOrInitialShelfContents(objectGraph, shelfToken); + for (const itemData of shelfContents) { + const metricsOptions = { + ...shelfToken.metricsImpressionOptions, + targetType: clickTargetForCollectionDisplayStyle(objectGraph, displayStyle), + recoMetricsData: mediaDataStructure.metricsFromMediaApiObject(itemData), + }; + if (!mediaAttributes.hasAttributes(itemData) || shouldDefer(shelfToken)) { + shelfToken.remainingItems.push(itemData); + shelfToken.isDeferring = true; + continue; + } + let storyCard = null; + if (preprocessor.GAMES_TARGET && gamesComponentBuilder.shouldUseMediaCard(displayStyle)) { + storyCard = gamesComponentBuilder.makeEditorialMediaCard(objectGraph, itemData, "Card", shelfToken, "Editorial"); + } + else { + storyCard = buildStoryCard(objectGraph, itemData, editorialMediaUtil.EditorialMediaPlacement.StoryCard, metricsOptions, shelfToken.collectionDisplayStyle, true, shelfToken); + } + if (isNull(storyCard)) { + continue; + } + items.push(storyCard); + metricsHelpersLocation.nextPosition(shelfToken.metricsImpressionOptions.locationTracker); + } + // We don't need this in our incomplete shelf URL, so we'll preemptively remove it. + delete shelfToken.maxItemCount; + shelf.eyebrow = shelfToken.eyebrow; + shelf.eyebrowArtwork = shelfToken.eyebrowArtwork; + shelf.title = shelfToken.title; + shelf.subtitle = shelfToken.subtitle; + if (preprocessor.GAMES_TARGET && + gamesComponentBuilder.shouldUseComponentGrid(displayStyle, layoutDirection, shelfToken)) { + const item = gamesComponentBuilder.makeComponentGrid(objectGraph, items, shelfToken, displayStyle); + shelf.items = isSome(item) ? [item] : []; + } + else { + shelf.items = items; + } + shelf.rowsPerColumn = mediaAttributes.attributeAsNumber(shelfToken.data, "rowCount"); + shelf.url = createShelfTokenUrlIfNecessary(objectGraph, shelf, shelfToken); + insertPlaceholdersIntoShelfIfRequired(objectGraph, shelf, shelfToken); + return shelf; +} +//# sourceMappingURL=editorial-page-story-card-collection-shelf-builder.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-story-card-utils.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-story-card-utils.js new file mode 100644 index 0000000..ff85e3d --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-story-card-utils.js @@ -0,0 +1,128 @@ +import * as models from "../../../../api/models"; +import * as content from "../../../content/content"; +import * as mediaDataStructure from "../../../../foundation/media/data-structure"; +import * as metricsHelpersImpressions from "../../../metrics/helpers/impressions"; +import * as editorialCopyUtil from "../../editorial-page-editorial-copy-util"; +import * as editorialOverlayContentUtil from "../../editorial-page-overlay-content-util"; +import { asBooleanOrFalse, isDefinedNonNull, isDefinedNonNullNonEmpty, } from "../../../../foundation/json-parsing/server-data"; +import * as editorialDataUtil from "../../editorial-data-util"; +import * as editorialActionUtil from "../../editorial-action-util"; +import * as editorialMediaUtil from "../../editorial-media-util"; +import * as mediaAttributes from "../../../../foundation/media/attributes"; +import { deepLinkUrlFromData } from "../../../linking/external-deep-link"; +import { shouldFilter } from "../../../filtering"; +import { mixedMediaItemFromEditorialData } from "../../../../gameservicesui/src/common/mixed-media-item-editorial-artwork"; +/** + * Build an `EditorialStoryCard` from the provided data. + * @param objectGraph The object graph. + * @param itemData Data for the card item being created. + * @param mediaPlacement The placement within which the card is being created for media. + * @param metricsOptions A set of metrics options. + * @param collectionDisplayStyle The collection display style for the shelf this is in. + * @param allowSuppressLockup Whether any lockup can be suppressed + * @param shelfToken A shelf token, if being presented within a shelf. If not, it's being used in another context. + * @returns The built editorial story card. + */ +export function buildStoryCard(objectGraph, itemData, mediaPlacement, metricsOptions, collectionDisplayStyle, allowSuppressLockup, shelfToken) { + var _a, _b; + const editorialClientParams = editorialDataUtil.extractEditorialClientParams(objectGraph, itemData); + const storyCard = new models.EditorialStoryCard(); + storyCard.title = editorialCopyUtil.editorialTitleFromData(objectGraph, itemData, collectionDisplayStyle); + if (!editorialClientParams.suppressShort) { + storyCard.description = editorialCopyUtil.editorialDescriptionFromData(objectGraph, itemData); + } + const hideEditorialMedia = asBooleanOrFalse(editorialClientParams.hideEditorialMedia); + if (!hideEditorialMedia) { + const mediaData = editorialMediaUtil.editorialMediaDataForPlacement(objectGraph, itemData, mediaPlacement); + storyCard.artwork = mediaData === null || mediaData === void 0 ? void 0 : mediaData.artwork; + storyCard.video = mediaData === null || mediaData === void 0 ? void 0 : mediaData.video; + storyCard.isMediaDark = (_a = editorialMediaUtil.isMediaDark(objectGraph, mediaData)) !== null && _a !== void 0 ? _a : undefined; + if (mediaPlacement === editorialMediaUtil.EditorialMediaPlacement.StoryDetail) { + if (preprocessor.GAMES_TARGET) { + storyCard.mixedMediaItem = mixedMediaItemFromEditorialData(objectGraph, itemData, "DetailStory"); + } + const landscapeMediaData = editorialMediaUtil.editorialMediaDataForPlacement(objectGraph, itemData, editorialMediaUtil.EditorialMediaPlacement.StoryDetailLandscape); + storyCard.landscapeArtwork = landscapeMediaData === null || landscapeMediaData === void 0 ? void 0 : landscapeMediaData.artwork; + storyCard.landscapeVideo = landscapeMediaData === null || landscapeMediaData === void 0 ? void 0 : landscapeMediaData.video; + storyCard.isLandscapeMediaDark = + (_b = editorialMediaUtil.isMediaDark(objectGraph, landscapeMediaData)) !== null && _b !== void 0 ? _b : undefined; + } + } + const lockupOptions = { + metricsOptions: { + pageInformation: metricsOptions.pageInformation, + locationTracker: metricsOptions.locationTracker, + recoMetricsData: mediaDataStructure.metricsFromMediaApiObject(itemData), + }, + artworkUseCase: 1 /* content.ArtworkUseCase.LockupIconSmall */, + offerEnvironment: editorialClientParams.useMaterialBlur ? "light" : "lightOverArtwork", + canDisplayArcadeOfferButton: content.shelfDisplayStyleCanDisplayArcadeOfferButtons(objectGraph, collectionDisplayStyle), + isContainedInPreorderExclusiveShelf: false, + externalDeepLinkUrl: deepLinkUrlFromData(objectGraph, itemData), + useJoeColorIconPlaceholder: preprocessor.GAMES_TARGET, + }; + const overlayContent = editorialOverlayContentUtil.extractOverlayContent(objectGraph, itemData, lockupOptions); + const suppressLockup = allowSuppressLockup && asBooleanOrFalse(editorialClientParams.suppressLockup); + if (!suppressLockup) { + storyCard.lockup = overlayContent.lockup; + } + // For Arcade app that is preorder and bincompat, we should override the badge to always display "COMING SOON" in upper cased. + const lockupData = editorialDataUtil.extractProductData(objectGraph, itemData); + const isPreorder = mediaAttributes.attributeAsBooleanOrFalse(lockupData, "isPreorder"); + const isArcadeLockup = content.isArcadeSupported(objectGraph, lockupData); + const supportsVisionOSCompatibleIOSBinary = content.supportsVisionOSCompatibleIOSBinaryFromData(objectGraph, lockupData); + // If there is lockup data, and we're not suppressing the lockup, check the data is valid for this platform. + // If this is for a story detail page, ignore these checks so that the artwork card is still presented as expected. + if (isDefinedNonNullNonEmpty(lockupData) && + !suppressLockup && + shouldFilter(objectGraph, lockupData, 80894 /* Filter.All */) && + mediaPlacement !== editorialMediaUtil.EditorialMediaPlacement.StoryDetail) { + return null; + } + let badgeText; + if (isPreorder && isArcadeLockup && supportsVisionOSCompatibleIOSBinary) { + badgeText = objectGraph.loc.string("ARCADE_PREORDER_COMING_SOON"); + } + else { + badgeText = editorialCopyUtil.editorialBadgeFromData(objectGraph, itemData, collectionDisplayStyle); + } + if (objectGraph.client.isVision && badgeText === objectGraph.loc.string("APPLE_ARCADE")) { + storyCard.badge = { + type: "arcadeWordmark", + }; + } + else { + storyCard.badge = { + type: "text", + title: badgeText, + }; + } + storyCard.collectionIcons = overlayContent.collectionIcons; + if (isDefinedNonNull(shelfToken)) { + const baseClickOptions = { + id: itemData.id, + pageInformation: shelfToken.metricsPageInformation, + locationTracker: shelfToken.metricsLocationTracker, + actionDetails: { + franchise: storyCard.badge.title, + }, + idType: "editorial_id", + }; + storyCard.clickAction = editorialActionUtil.createPrimaryActionForComponentFromData(objectGraph, itemData, shelfToken, baseClickOptions); + } + storyCard.editorialDisplayOptions = + editorialDataUtil.editorialDisplayOptionsFromClientParams(editorialClientParams); + // Configure impressions + const contentMetricsOptions = { + ...metricsOptions, + id: itemData.id, + idType: "editorial_id", + }; + const impressionOptions = metricsHelpersImpressions.impressionOptions(objectGraph, itemData, storyCard.title, contentMetricsOptions); + metricsHelpersImpressions.addImpressionFields(objectGraph, storyCard, impressionOptions); + if (!storyCard.isValid()) { + return null; + } + return storyCard; +} +//# sourceMappingURL=editorial-page-story-card-utils.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-text-only-collection-shelf-builder.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-text-only-collection-shelf-builder.js new file mode 100644 index 0000000..3f9f2b7 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-text-only-collection-shelf-builder.js @@ -0,0 +1,54 @@ +import * as models from "../../../../api/models"; +import * as serverData from "../../../../foundation/json-parsing/server-data"; +import * as mediaAttributes from "../../../../foundation/media/attributes"; +import * as metricsHelpersLocation from "../../../metrics/helpers/location"; +import * as editorialActionUtil from "../../editorial-action-util"; +import * as editorialDataUtil from "../../editorial-data-util"; +import * as editorialCopyUtil from "../../editorial-page-editorial-copy-util"; +import { CollectionShelfLayoutDirection } from "../../editorial-page-types"; +import { createShelfTokenUrlIfNecessary, shouldDefer } from "./editorial-page-collection-shelf-common"; +import * as metricsHelpersImpressions from "../../../metrics/helpers/impressions"; +import { insertPlaceholdersIntoShelfIfRequired } from "../../../placeholders/placeholders"; +export function buildTextOnlyShelf(objectGraph, shelfToken) { + var _a; + const items = []; + const shelf = new models.Shelf("action"); + shelf.isHorizontal = + mediaAttributes.attributeAsString(shelfToken.data, "layoutDirection") === + CollectionShelfLayoutDirection.Horizontal; + const shelfContents = editorialDataUtil.extractRemainingItemsOrInitialShelfContents(objectGraph, shelfToken); + for (const itemData of shelfContents) { + if (serverData.isNull(itemData.attributes) || shouldDefer(shelfToken)) { + shelfToken.isDeferring = true; + shelfToken.remainingItems.push(itemData); + continue; + } + const action = editorialActionUtil.createPrimaryActionForComponentFromData(objectGraph, itemData, shelfToken); + action.title = editorialCopyUtil.editorialTitleFromData(objectGraph, itemData, shelfToken.collectionDisplayStyle); + // Configure impressions + const contentMetricsOptions = { + ...shelfToken.metricsImpressionOptions, + id: itemData.id, + idType: "editorial_id", + targetType: "textOnly", + }; + const impressionOptions = metricsHelpersImpressions.impressionOptions(objectGraph, itemData, action.title, contentMetricsOptions); + metricsHelpersImpressions.addImpressionFields(objectGraph, action, impressionOptions); + if (action.isValid()) { + items.push(action); + metricsHelpersLocation.nextPosition(shelfToken.metricsImpressionOptions.locationTracker); + } + } + // We don't need this in our incomplete shelf URL, so we'll preemptively remove it. + delete shelfToken.maxItemCount; + shelf.eyebrow = shelfToken.eyebrow; + shelf.eyebrowArtwork = shelfToken.eyebrowArtwork; + shelf.title = shelfToken.title; + shelf.subtitle = shelfToken.subtitle; + shelf.items = items; + shelf.rowsPerColumn = (_a = mediaAttributes.attributeAsNumber(shelfToken.data, "rowCount")) !== null && _a !== void 0 ? _a : 1; + shelf.url = createShelfTokenUrlIfNecessary(objectGraph, shelf, shelfToken); + insertPlaceholdersIntoShelfIfRequired(objectGraph, shelf, shelfToken); + return shelf; +} +//# sourceMappingURL=editorial-page-text-only-collection-shelf-builder.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-text-with-artwork-collection-shelf-builder.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-text-with-artwork-collection-shelf-builder.js new file mode 100644 index 0000000..7587b49 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-text-with-artwork-collection-shelf-builder.js @@ -0,0 +1,66 @@ +import * as models from "../../../../api/models"; +import * as serverData from "../../../../foundation/json-parsing/server-data"; +import * as mediaAttributes from "../../../../foundation/media/attributes"; +import * as content from "../../../content/content"; +import * as metricsHelpersLocation from "../../../metrics/helpers/location"; +import { insertPlaceholdersIntoShelfIfRequired } from "../../../placeholders/placeholders"; +import * as editorialActionUtil from "../../editorial-action-util"; +import * as editorialDataUtil from "../../editorial-data-util"; +import * as editorialCopyUtil from "../../editorial-page-editorial-copy-util"; +import { CollectionShelfLayoutDirection } from "../../editorial-page-types"; +import { createShelfTokenUrlIfNecessary, shouldDefer } from "./editorial-page-collection-shelf-common"; +import * as gamesComponentBuilder from "../../../../gameservicesui/src/editorial-page/editorial-component-builder"; +export function buildTextWithArtworkShelf(objectGraph, shelfToken) { + var _a; + const items = []; + const shelf = new models.Shelf("action"); + shelf.isHorizontal = + mediaAttributes.attributeAsString(shelfToken.data, "layoutDirection") === + CollectionShelfLayoutDirection.Horizontal; + const shelfContents = editorialDataUtil.extractRemainingItemsOrInitialShelfContents(objectGraph, shelfToken); + for (const itemData of shelfContents) { + if (serverData.isNull(itemData.attributes) || shouldDefer(shelfToken)) { + shelfToken.isDeferring = true; + shelfToken.remainingItems.push(itemData); + continue; + } + const action = editorialActionUtil.createPrimaryActionForComponentFromData(objectGraph, itemData, shelfToken); + action.title = editorialCopyUtil.editorialTitleFromData(objectGraph, itemData, shelfToken.collectionDisplayStyle); + let artwork; + if (preprocessor.GAMES_TARGET) { + const editorialArtwork = mediaAttributes.attributeAsDictionary(itemData, "editorialArtwork"); + artwork = serverData.asDictionary(editorialArtwork, "contentIconTrimmed"); + } + else { + artwork = mediaAttributes.attributeAsDictionary(itemData, "artwork"); + } + if (serverData.isDefinedNonNullNonEmpty(artwork)) { + action.artwork = content.artworkFromApiArtwork(objectGraph, artwork, { + allowingTransparency: true, + useCase: 20 /* content.ArtworkUseCase.CategoryIcon */, + }); + } + if (action.isValid()) { + items.push(action); + metricsHelpersLocation.nextPosition(shelfToken.metricsImpressionOptions.locationTracker); + } + } + // We don't need this in our incomplete shelf URL, so we'll preemptively remove it. + delete shelfToken.maxItemCount; + shelf.eyebrow = shelfToken.eyebrow; + shelf.eyebrowArtwork = shelfToken.eyebrowArtwork; + shelf.title = shelfToken.title; + shelf.subtitle = shelfToken.subtitle; + if (preprocessor.GAMES_TARGET) { + shelf.items = [gamesComponentBuilder.makeRibbonBar(objectGraph, items)]; + shelf.contentType = "ribbonBar"; + } + else { + shelf.items = items; + } + shelf.rowsPerColumn = (_a = mediaAttributes.attributeAsNumber(shelfToken.data, "rowCount")) !== null && _a !== void 0 ? _a : 1; + shelf.url = createShelfTokenUrlIfNecessary(objectGraph, shelf, shelfToken); + insertPlaceholdersIntoShelfIfRequired(objectGraph, shelf, shelfToken); + return shelf; +} +//# sourceMappingURL=editorial-page-text-with-artwork-collection-shelf-builder.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/index.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/index.js new file mode 100644 index 0000000..ae02877 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-collection-shelf-builder/index.js @@ -0,0 +1,113 @@ +import * as serverData from "../../../../foundation/json-parsing/server-data"; +import { attributeAsString } from "../../../../foundation/media/attributes"; +import { CollectionShelfDisplayStyle } from "../../editorial-page-types"; +import { buildBreakoutLargeShelf } from "./editorial-page-breakout-large-collection-shelf-builder"; +import { buildBrickLargeShelf, buildBrickMediumShelf, buildBrickSmallShelf, } from "./editorial-page-brick-collection-shelf-builder"; +import { createShelfSeeAllActionIfNecessary } from "./editorial-page-collection-shelf-common"; +import { buildHeroShelf } from "./editorial-page-hero-collection-shelf-builder"; +import { buildEditorialLockupLargeShelf, buildEditorialLockupLargeVariantShelf, buildEditorialLockupMediumShelf, buildEditorialLockupMediumVariantShelf, buildLockupLargeShelf, buildLockupSmallShelf, buildEditorialLockupPosterShelf, buildEditorialLockupHierarchicalRows, buildEditorialLockupHierarchicalPortrait, buildLockupMedium, } from "./editorial-page-lockup-collection-shelf-builder"; +import { buildMediumStoryCardShelf, buildSmallStoryCardShelf, } from "./editorial-page-story-card-collection-shelf-builder"; +import { buildTextOnlyShelf } from "./editorial-page-text-only-collection-shelf-builder"; +import { buildTextWithArtworkShelf } from "./editorial-page-text-with-artwork-collection-shelf-builder"; +import { collectionShelfDisplayStyleFromShelfData } from "../../editorial-data-util"; +import * as gamesHeroShelfBuilder from "../../../../gameservicesui/src/editorial-page/editorial-page-hero-collection-shelf-builder"; +import { isSome } from "@jet/environment"; +export function buildCollectionShelf(objectGraph, shelfToken) { + let collectionDisplayStyle = attributeAsString(shelfToken.data, "displayStyle"); + if (preprocessor.GAMES_TARGET) { + // A way to override display style as design wants to see large cards in "See all" rooms. + const shelfTokenStyle = shelfToken.collectionDisplayStyle; + if (isSome(shelfTokenStyle) && shelfTokenStyle !== collectionDisplayStyle) { + collectionDisplayStyle = shelfToken.collectionDisplayStyle; + } + } + if (serverData.isNullOrEmpty(collectionDisplayStyle)) { + return null; + } + let shelf = null; + switch (collectionDisplayStyle) { + case CollectionShelfDisplayStyle.Hero: + if (preprocessor.GAMES_TARGET) { + shelf = gamesHeroShelfBuilder.buildHeroShelf(objectGraph, shelfToken); + } + else { + shelf = buildHeroShelf(objectGraph, shelfToken); + } + break; + case CollectionShelfDisplayStyle.TextOnly: + shelf = buildTextOnlyShelf(objectGraph, shelfToken); + break; + case CollectionShelfDisplayStyle.TextWithArtwork: + shelf = buildTextWithArtworkShelf(objectGraph, shelfToken); + break; + case CollectionShelfDisplayStyle.BrickSmall: + shelf = buildBrickSmallShelf(objectGraph, shelfToken); + break; + case CollectionShelfDisplayStyle.BrickMedium: + shelf = buildBrickMediumShelf(objectGraph, shelfToken); + break; + case CollectionShelfDisplayStyle.BrickLarge: + shelf = buildBrickLargeShelf(objectGraph, shelfToken); + break; + case CollectionShelfDisplayStyle.EditorialLockupHierarchicalPortrait: + shelf = buildEditorialLockupHierarchicalPortrait(objectGraph, shelfToken); + break; + case CollectionShelfDisplayStyle.EditorialLockupHierarchicalRows: + shelf = buildEditorialLockupHierarchicalRows(objectGraph, shelfToken); + break; + case CollectionShelfDisplayStyle.EditorialLockupMedium: + shelf = buildEditorialLockupMediumShelf(objectGraph, shelfToken); + break; + case CollectionShelfDisplayStyle.EditorialLockupMediumVariant: + shelf = buildEditorialLockupMediumVariantShelf(objectGraph, shelfToken); + break; + case CollectionShelfDisplayStyle.EditorialLockupLarge: + shelf = buildEditorialLockupLargeShelf(objectGraph, shelfToken); + break; + case CollectionShelfDisplayStyle.EditorialLockupLargeVariant: + shelf = buildEditorialLockupLargeVariantShelf(objectGraph, shelfToken); + break; + case CollectionShelfDisplayStyle.LockupMedium: + shelf = buildLockupMedium(objectGraph, shelfToken); + break; + case CollectionShelfDisplayStyle.Poster: + shelf = buildEditorialLockupPosterShelf(objectGraph, shelfToken); + break; + case CollectionShelfDisplayStyle.StorySmall: + shelf = buildSmallStoryCardShelf(objectGraph, shelfToken); + break; + case CollectionShelfDisplayStyle.StoryMedium: + shelf = buildMediumStoryCardShelf(objectGraph, shelfToken); + break; + case CollectionShelfDisplayStyle.LockupSmall: + shelf = buildLockupSmallShelf(objectGraph, shelfToken); + break; + case CollectionShelfDisplayStyle.LockupLarge: + shelf = buildLockupLargeShelf(objectGraph, shelfToken); + break; + case CollectionShelfDisplayStyle.BreakoutLarge: + shelf = buildBreakoutLargeShelf(objectGraph, shelfToken); + break; + default: + break; + } + if (serverData.isDefinedNonNullNonEmpty(shelf)) { + shelf.seeAllAction = createShelfSeeAllActionIfNecessary(objectGraph, shelf, shelfToken); + shelf.id = `shelf_${shelfToken.id}`; + } + return shelf; +} +/** + * Decorates the input shelf metrics options with shelf specific fields. + * @param objectGraph Current object graph + * @param shelfMetricsOptions Base shelf metrics options + * @returns Decorated shelf metrics options + */ +export function decorateCollectionShelfMetricsOptions(objectGraph, shelfData, shelfMetricsOptions) { + const collectionDisplayStyle = collectionShelfDisplayStyleFromShelfData(objectGraph, shelfData); + if (serverData.isNullOrEmpty(collectionDisplayStyle)) { + return; + } + shelfMetricsOptions.displayStyle = collectionDisplayStyle; +} +//# sourceMappingURL=index.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-engagement-shelf-builder.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-engagement-shelf-builder.js new file mode 100644 index 0000000..76756a7 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-engagement-shelf-builder.js @@ -0,0 +1,4 @@ +export function buildEngagementShelf(objectGraph, shelfToken) { + return null; +} +//# sourceMappingURL=editorial-page-engagement-shelf-builder.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-game-center-shelf-builder.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-game-center-shelf-builder.js new file mode 100644 index 0000000..7de4145 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-game-center-shelf-builder.js @@ -0,0 +1,4 @@ +export function buildGameCenterShelf(objectGraph, shelfToken) { + return null; +} +//# sourceMappingURL=editorial-page-game-center-shelf-builder.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-header-shelf-builder.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-header-shelf-builder.js new file mode 100644 index 0000000..0f3a98f --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-header-shelf-builder.js @@ -0,0 +1,157 @@ +import { attributeAsString } from "@apple-media-services/media-api"; +import { isSome } from "@jet/environment/types/optional"; +import * as models from "../../../api/models"; +import { asBooleanOrFalse, isDefinedNonNullNonEmpty } from "../../../foundation/json-parsing/server-data"; +import { attributeAsDictionary } from "../../../foundation/media/attributes"; +import { metricsFromMediaApiObject } from "../../../foundation/media/data-structure"; +import * as color from "../../../foundation/util/color-util"; +import { shallowCopyOf } from "../../../foundation/util/objects"; +import * as gamesComponentBuilder from "../../../gameservicesui/src/editorial-page/editorial-component-builder"; +import * as content from "../../content/content"; +import { deepLinkUrlFromData } from "../../linking/external-deep-link"; +import { popLocation, pushBasicLocation } from "../../metrics/helpers/location"; +import { areAppTagsEnabled } from "../../util/app-tags-util"; +import { editorialDisplayOptionsFromClientParams, extractEditorialClientParams } from "../editorial-data-util"; +import { editorialMediaDataForPlacement, EditorialMediaPlacement, isMediaDark, } from "../editorial-media-util"; +import * as editorialComponentMediaUtil from "../editorial-page-component-media-util"; +import { heroOverlayFromData } from "../editorial-page-hero-util"; +import * as metricsHelpersImpressions from "../../metrics/helpers/impressions"; +/** + * Build a header shelf for the editorial page, if present. + * @param objectGraph The App Store object graph. + * @param pageData The data for the editorial page. + * @param shelfToken The shelf token. + * @returns A Shelf, if the data is available. + */ +export function buildHeaderShelf(objectGraph, pageData, shelfToken) { + var _a, _b, _c; + const shouldUseShelfData = isDefinedNonNullNonEmpty(attributeAsDictionary(shelfToken.data, "editorialNotes")); + const headerData = shouldUseShelfData ? shelfToken.data : pageData; + if (!headerData) { + return null; + } + if (preprocessor.GAMES_TARGET) { + return gamesComponentBuilder.makeGamesPageHeaderFromData(objectGraph, headerData, shelfToken); + } + const editorialArtworkData = isDefinedNonNullNonEmpty(attributeAsDictionary(headerData, "editorialArtwork")); + if (editorialArtworkData) { + const pageHeader = new models.HeroCarousel(); + const pageHeaderCarouselItem = new models.HeroCarouselItem(); + const editorialClientParams = extractEditorialClientParams(objectGraph, headerData); + const pageHeaderCarouselItemOverlay = heroOverlayFromData(objectGraph, headerData, shelfToken, editorialClientParams); + pageHeaderCarouselItemOverlay.overlayType = "text"; + pageHeaderCarouselItemOverlay.callToActionText = null; + pageHeaderCarouselItem.clickAction = null; + pageHeaderCarouselItemOverlay.collectionIcons = null; + pageHeaderCarouselItemOverlay.lockup = null; + pageHeaderCarouselItemOverlay.callToActionText = null; + pageHeaderCarouselItem.overlay = pageHeaderCarouselItemOverlay; + const lockupOptions = { + artworkUseCase: 1 /* content.ArtworkUseCase.LockupIconSmall */, + offerStyle: "transparent", + offerEnvironment: "dark", + canDisplayArcadeOfferButton: content.shelfDisplayStyleCanDisplayArcadeOfferButtons(objectGraph, shelfToken.collectionDisplayStyle), + isContainedInPreorderExclusiveShelf: false, + metricsOptions: { + pageInformation: shelfToken.metricsPageInformation, + locationTracker: shelfToken.metricsLocationTracker, + recoMetricsData: metricsFromMediaApiObject(headerData), + }, + externalDeepLinkUrl: deepLinkUrlFromData(objectGraph, headerData), + }; + pushBasicLocation(objectGraph, lockupOptions.metricsOptions, "collectionIcons"); + const collectionIcons = editorialComponentMediaUtil.editorialFallbackAppIconsFromData(objectGraph, headerData, lockupOptions); + popLocation(lockupOptions.metricsOptions.locationTracker); + pageHeaderCarouselItem.collectionIcons = collectionIcons; + const heroMediaData = editorialMediaDataForPlacement(objectGraph, headerData, EditorialMediaPlacement.Hero); + const hideEditorialMedia = asBooleanOrFalse(editorialClientParams.hideEditorialMedia); + populatePageHeaderCarouselItemMedia(objectGraph, pageHeaderCarouselItem, hideEditorialMedia, heroMediaData, false); + pageHeaderCarouselItem.editorialDisplayOptions = editorialDisplayOptionsFromClientParams(editorialClientParams); + pageHeader.items = [pageHeaderCarouselItem]; + const rtlPageHeaderCarouselItem = shallowCopyOf(pageHeaderCarouselItem); + populatePageHeaderCarouselItemMedia(objectGraph, rtlPageHeaderCarouselItem, hideEditorialMedia, heroMediaData, true); + pageHeader.rtlItems = [rtlPageHeaderCarouselItem]; + const shelf = new models.Shelf("heroCarousel"); + shelf.items = [pageHeader]; + return shelf; + } + else { + const editorialName = attributeAsString(headerData, "name"); + if (isDefinedNonNullNonEmpty(editorialName) && areAppTagsEnabled(objectGraph, null)) { + const shelf = new models.Shelf("mediaPageHeader"); + shelf.id = "mediaPageHeader"; + const editorialBadge = (_a = attributeAsString(headerData, "editorialNotes.badge")) !== null && _a !== void 0 ? _a : null; + const lockupOptions = { + artworkUseCase: 1 /* content.ArtworkUseCase.LockupIconSmall */, + offerStyle: "transparent", + offerEnvironment: "dark", + canDisplayArcadeOfferButton: content.shelfDisplayStyleCanDisplayArcadeOfferButtons(objectGraph, shelfToken.collectionDisplayStyle), + isContainedInPreorderExclusiveShelf: false, + metricsOptions: { + pageInformation: shelfToken.metricsPageInformation, + locationTracker: shelfToken.metricsLocationTracker, + recoMetricsData: metricsFromMediaApiObject(headerData), + }, + externalDeepLinkUrl: deepLinkUrlFromData(objectGraph, headerData), + useJoeColorIconPlaceholder: true, + joeColorPlaceholderSelectionLogic: content.bestJoeColorPlaceholderSelectionLogic, + }; + let collectionIcons = (_b = editorialComponentMediaUtil.editorialFallbackAppIconsFromData(objectGraph, shelfToken.data, lockupOptions)) !== null && _b !== void 0 ? _b : undefined; + let backgroundColor; + if (isSome(collectionIcons) && (collectionIcons === null || collectionIcons === void 0 ? void 0 : collectionIcons.length) >= 3) { + collectionIcons = collectionIcons.slice(0, 3); + const collectionIconBackgroundColor = collectionIcons[0].backgroundColor; + if (isSome(collectionIconBackgroundColor) && (collectionIconBackgroundColor === null || collectionIconBackgroundColor === void 0 ? void 0 : collectionIconBackgroundColor.type) === "rgb") { + backgroundColor = content.closestTagBackgroundColorForIcon(collectionIconBackgroundColor); + } + const isArtworkDark = color.isDarkColor(backgroundColor); + const editorialClientParams = extractEditorialClientParams(objectGraph, shelfToken.data); + const mediaPageHeader = new models.MediaPageHeader(editorialBadge, editorialName, null, undefined, undefined, collectionIcons, false, backgroundColor !== null && backgroundColor !== void 0 ? backgroundColor : undefined, convertHintToIconCollectionStyle((_c = editorialClientParams.fallbackDisplayStyleHint) !== null && _c !== void 0 ? _c : "one", collectionIcons === null || collectionIcons === void 0 ? void 0 : collectionIcons.length), isArtworkDark ? "dark" : "light"); + // Configure impressions + const metricsOptions = { + pageInformation: shelfToken.metricsPageInformation, + locationTracker: shelfToken.metricsLocationTracker, + recoMetricsData: metricsFromMediaApiObject(headerData), + }; + const impressionOptions = metricsHelpersImpressions.impressionOptionsForTagHeader(objectGraph, headerData, editorialName, metricsOptions); + metricsHelpersImpressions.addImpressionFieldsToTagRoomHeader(objectGraph, mediaPageHeader, impressionOptions); + shelf.items = [mediaPageHeader]; + return shelf; + } + else { + return null; + } + } + else { + return null; + } + } +} +function convertHintToIconCollectionStyle(hint, artworkCount) { + if (artworkCount === 2) { + return "TwoUp"; + } + else { + switch (hint) { + case "one": + return "ThreeUp"; + case "two": + return "Fan"; + case "three": + return "Asymmetrical"; + default: + return "ThreeUp"; + } + } +} +function populatePageHeaderCarouselItemMedia(objectGraph, pageHeaderCarouselItem, hideEditorialMedia, heroMediaData, isRTL) { + if (!hideEditorialMedia) { + pageHeaderCarouselItem.backgroundColor = isRTL + ? heroMediaData === null || heroMediaData === void 0 ? void 0 : heroMediaData.rtlBackgroundColor + : heroMediaData === null || heroMediaData === void 0 ? void 0 : heroMediaData.backgroundColor; + pageHeaderCarouselItem.artwork = isRTL ? heroMediaData === null || heroMediaData === void 0 ? void 0 : heroMediaData.rtlArtwork : heroMediaData === null || heroMediaData === void 0 ? void 0 : heroMediaData.artwork; + pageHeaderCarouselItem.video = isRTL ? heroMediaData === null || heroMediaData === void 0 ? void 0 : heroMediaData.rtlVideo : heroMediaData === null || heroMediaData === void 0 ? void 0 : heroMediaData.video; + } + pageHeaderCarouselItem.isMediaDark = isMediaDark(objectGraph, heroMediaData, isRTL); +} +//# sourceMappingURL=editorial-page-header-shelf-builder.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-image-shelf-builder.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-image-shelf-builder.js new file mode 100644 index 0000000..44ce98e --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-image-shelf-builder.js @@ -0,0 +1,4 @@ +export function buildImageShelf(objectGraph, shelfToken) { + return null; +} +//# sourceMappingURL=editorial-page-image-shelf-builder.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-marker-shelf-builder/editorial-page-quick-links-marker-shelf-builder.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-marker-shelf-builder/editorial-page-quick-links-marker-shelf-builder.js new file mode 100644 index 0000000..0f3b482 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-marker-shelf-builder/editorial-page-quick-links-marker-shelf-builder.js @@ -0,0 +1,71 @@ +import { isSome } from "@jet/environment/types/optional"; +import * as models from "../../../../api/models"; +import * as artworkBuilder from "../../../content/artwork/artwork"; +import * as metricsHelpersClicks from "../../../metrics/helpers/clicks"; +export function buildQuickLinksShelf(objectGraph, shelfToken) { + if (objectGraph.user && objectGraph.user.isManagedAppleID) { + return null; + } + // Watch App Store does not support titled button stacks, + // and has different footer buttons. + if (objectGraph.client.isWatch) { + const shelf = new models.Shelf("action"); + const items = []; + const accountFlowAction = new models.FlowAction("account"); + accountFlowAction.title = objectGraph.loc.string("ACCOUNT", "Account"); + accountFlowAction.artwork = artworkBuilder.createArtworkForResource(objectGraph, "systemimage://person.crop.circle"); + const accountFlowClickOptions = { + targetType: "button", + id: "account", + pageInformation: shelfToken.metricsPageInformation, + locationTracker: shelfToken.metricsLocationTracker, + }; + metricsHelpersClicks.addClickEventToAction(objectGraph, accountFlowAction, accountFlowClickOptions); + items.push(accountFlowAction); + shelf.items = items; + return shelf; + } + else { + const items = []; + if (isSome(objectGraph.bag.aboutAppStoreUrl)) { + const aboutAppStoreAction = new models.ExternalUrlAction(objectGraph.bag.aboutAppStoreUrl); + aboutAppStoreAction.title = objectGraph.loc.string("QuickLinks.AboutTheAppStore.Title"); + items.push(aboutAppStoreAction); + } + if (isSome(objectGraph.bag.aboutInAppPurchasesEditorialItemId)) { + const aboutIAPsFlowAction = new models.FlowAction("article"); + aboutIAPsFlowAction.title = objectGraph.loc.string("QuickLinks.AboutInAppPurchases.Title"); + aboutIAPsFlowAction.pageUrl = `https://apps.apple.com/story/id${objectGraph.bag.aboutInAppPurchasesEditorialItemId}`; + items.push(aboutIAPsFlowAction); + } + if (isSome(objectGraph.bag.reportProblemUrl)) { + const reportProblemAction = new models.ExternalUrlAction(objectGraph.bag.reportProblemUrl); + reportProblemAction.title = objectGraph.loc.string("REPORT_A_PROBLEM", "Report a Problem"); + items.push(reportProblemAction); + } + if (isSome(objectGraph.bag.requestARefundUrl)) { + const requestRefundAction = new models.ExternalUrlAction(objectGraph.bag.requestARefundUrl); + requestRefundAction.title = objectGraph.loc.string("QuickLinks.RequestARefund.Title"); + items.push(requestRefundAction); + } + if (isSome(objectGraph.bag.changePaymentMethodUrl)) { + const changePaymentMethodAction = new models.ExternalUrlAction(objectGraph.bag.changePaymentMethodUrl); + changePaymentMethodAction.title = objectGraph.loc.string("QuickLinks.ChangePaymentMethod.Title"); + items.push(changePaymentMethodAction); + } + if (isSome(objectGraph.bag.aboutFrenchAppStoreEditorialItemId)) { + const aboutFrenchAppStoreFlowAction = new models.FlowAction("article"); + aboutFrenchAppStoreFlowAction.title = objectGraph.loc.string("QuickLinks.AboutFrenchAppStore.Title"); + aboutFrenchAppStoreFlowAction.pageUrl = `https://apps.apple.com/story/id${objectGraph.bag.aboutFrenchAppStoreEditorialItemId}`; + items.push(aboutFrenchAppStoreFlowAction); + } + const shelf = new models.Shelf("action"); + shelf.title = objectGraph.loc.string("QuickLinks.Title"); + shelf.items = items; + shelf.isHorizontal = true; + shelf.rowsPerColumn = 1; + shelfToken.metricsImpressionOptions.title = shelf.title; + return shelf; + } +} +//# sourceMappingURL=editorial-page-quick-links-marker-shelf-builder.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-marker-shelf-builder/index.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-marker-shelf-builder/index.js new file mode 100644 index 0000000..6392f23 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-marker-shelf-builder/index.js @@ -0,0 +1,20 @@ +import * as serverData from "../../../../foundation/json-parsing/server-data"; +import { attributeAsString } from "../../../../foundation/media/attributes"; +import { MarkerShelfKind } from "../../editorial-page-types"; +import { buildQuickLinksShelf } from "./editorial-page-quick-links-marker-shelf-builder"; +export function buildMarkerShelf(objectGraph, shelfToken) { + const markerKind = attributeAsString(shelfToken.data, "kind"); + if (serverData.isNullOrEmpty(markerKind)) { + return null; + } + let shelf = null; + switch (markerKind) { + case MarkerShelfKind.QuickLinks: + shelf = buildQuickLinksShelf(objectGraph, shelfToken); + break; + default: + break; + } + return shelf; +} +//# sourceMappingURL=index.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-recommendations-shelf-builder.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-recommendations-shelf-builder.js new file mode 100644 index 0000000..828d652 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-recommendations-shelf-builder.js @@ -0,0 +1,77 @@ +import { isNothing, isSome } from "@jet/environment"; +import * as models from "../../../api/models"; +import { isDefinedNonNullNonEmpty } from "../../../foundation/json-parsing/server-data"; +import { attributeAsBooleanOrFalse, attributeAsString } from "../../../foundation/media/attributes"; +import { Request } from "../../../foundation/media/data-fetching"; +import { relationshipCollection } from "../../../foundation/media/relationships"; +import { buildURLFromRequest } from "../../../foundation/media/url-builder"; +import { Parameters } from "../../../foundation/network/url-constants"; +import { insertPlaceholdersIntoShelfIfRequired } from "../../placeholders/placeholders"; +import { CollectionShelfDisplayStyle } from "../editorial-page-types"; +import { createShelfSeeAllActionIfNecessary, createShelfTokenUrlIfNecessary, } from "./editorial-page-collection-shelf-builder/editorial-page-collection-shelf-common"; +import { buildEditorialLockupHierarchicalPortrait, buildEditorialLockupLargeShelf, buildLockupLargeShelf, buildLockupSmallShelf, } from "./editorial-page-collection-shelf-builder/editorial-page-lockup-collection-shelf-builder"; +export function buildRecommendationsShelf(objectGraph, shelfToken) { + let collectionDisplayStyle = attributeAsString(shelfToken.data, "displayStyle"); + if (preprocessor.GAMES_TARGET) { + // A way to override display style as design wants to see large cards in "See all" rooms. + const shelfTokenStyle = shelfToken.collectionDisplayStyle; + if (isSome(shelfTokenStyle) && shelfTokenStyle !== collectionDisplayStyle) { + collectionDisplayStyle = shelfToken.collectionDisplayStyle; + } + } + let shelf = null; + switch (collectionDisplayStyle) { + case CollectionShelfDisplayStyle.LockupSmall: + shelf = buildLockupSmallShelf(objectGraph, shelfToken, false); + break; + case CollectionShelfDisplayStyle.LockupLarge: + shelf = buildLockupLargeShelf(objectGraph, shelfToken, false); + break; + case CollectionShelfDisplayStyle.EditorialLockupHierarchicalPortrait: + shelf = buildEditorialLockupHierarchicalPortrait(objectGraph, shelfToken); + break; + case CollectionShelfDisplayStyle.EditorialLockupLarge: + shelf = buildEditorialLockupLargeShelf(objectGraph, shelfToken); + break; + default: + shelf = shelfToken.isFirstRender ? makeHiddenShelf() : null; + break; + } + if (isNothing(shelf)) { + return null; + } + shelf.id = `shelf_${shelfToken.id}`; + addRecommendationsHrefIfNecessary(objectGraph, shelfToken); + shelf.url = createShelfTokenUrlIfNecessary(objectGraph, shelf, shelfToken); + insertPlaceholdersIntoShelfIfRequired(objectGraph, shelf, shelfToken); + shelf.seeAllAction = createShelfSeeAllActionIfNecessary(objectGraph, shelf, shelfToken); + return shelf; +} +/** + * Add the recommendations href for out of band reqeusts if necessary + * @param shelfToken The shelf token to add the href to + */ +function addRecommendationsHrefIfNecessary(objectGraph, shelfToken) { + const hasRecommendedContents = isDefinedNonNullNonEmpty(relationshipCollection(shelfToken.data, "contents")) || + isDefinedNonNullNonEmpty(shelfToken.remainingItems); + const isPersonalizationAvailable = attributeAsBooleanOrFalse(shelfToken.data, "isPersonalizationAvailable"); + const baseHref = shelfToken.data.href; + const shouldAddHref = isPersonalizationAvailable && !hasRecommendedContents && isDefinedNonNullNonEmpty(baseHref); + if (!shouldAddHref) { + return; + } + const recommendationsRequest = new Request(objectGraph, shelfToken.data.href) + .addingQuery(Parameters.editorialPageId, shelfToken.pageId) + .includingRelationships(["contents"]); + const recommendationsUrl = buildURLFromRequest(objectGraph, recommendationsRequest); + shelfToken.recommendationsHref = recommendationsUrl.toString(); +} +/** + * Creates a hidden shelf for when we're performing a secondary fetch and need to hide a shelf that returns null + */ +function makeHiddenShelf() { + const hiddenShelf = new models.Shelf("placeholder"); + hiddenShelf.isHidden = true; + return hiddenShelf; +} +//# sourceMappingURL=editorial-page-recommendations-shelf-builder.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-tag-shelf-builder.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-tag-shelf-builder.js new file mode 100644 index 0000000..9378611 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-tag-shelf-builder.js @@ -0,0 +1,4 @@ +export function buildTagShelf(objectGraph, shelfToken) { + return null; +} +//# sourceMappingURL=editorial-page-tag-shelf-builder.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-text-shelf-builder.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-text-shelf-builder.js new file mode 100644 index 0000000..3b8fd26 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-text-shelf-builder.js @@ -0,0 +1,19 @@ +import * as models from "../../../api/models"; +import { isNothing } from "@jet/environment"; +import { makeShelfId } from "../../../gameservicesui/src/editorial-page/editorial-component-builder"; +import * as mediaAPI from "@apple-media-services/media-api"; +export function buildTextShelf(objectGraph, shelfToken) { + if (!preprocessor.GAMES_TARGET) { + return null; + } + const shelf = new models.Shelf("paragraph"); + shelf.id = makeShelfId(shelfToken).toString(); + const editorialCopy = mediaAPI.attributeAsString(shelfToken.data, "editorialCopy"); + if (isNothing(editorialCopy)) { + return null; + } + const paragraph = new models.Paragraph(editorialCopy, "text/x-apple-as3-nqml", "article"); + shelf.items = [paragraph]; + return shelf; +} +//# sourceMappingURL=editorial-page-text-shelf-builder.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-upsell-shelf-builder.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-upsell-shelf-builder.js new file mode 100644 index 0000000..deb0ac9 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-upsell-shelf-builder.js @@ -0,0 +1,31 @@ +import * as models from "../../../api/models"; +import * as serverData from "../../../foundation/json-parsing/server-data"; +import * as arcadeCommon from "../../arcade/arcade-common"; +import * as arcadeUpsell from "../../arcade/arcade-upsell"; +import * as metricsHelpersLocation from "../../metrics/helpers/location"; +import * as metricsHelpersUtil from "../../metrics/helpers/util"; +import { makeGamesPageUpsellHeaderFromData } from "../../../gameservicesui/src/editorial-page/editorial-component-builder"; +export function buildUpsellShelf(objectGraph, shelfToken) { + if (preprocessor.GAMES_TARGET) { + return makeGamesPageUpsellHeaderFromData(objectGraph, shelfToken); + } + const upsellData = arcadeCommon.upsellFromRelationshipOf(objectGraph, shelfToken.data); + if (serverData.isNullOrEmpty(upsellData)) { + return null; + } + const marketingItemData = upsellData.marketingItemData; + if (serverData.isNullOrEmpty(marketingItemData) || serverData.isNullOrEmpty(marketingItemData.attributes)) { + return null; + } + const metricsOptions = { + pageInformation: shelfToken.metricsPageInformation, + locationTracker: shelfToken.metricsLocationTracker, + mercuryMetricsData: metricsHelpersUtil.marketingItemTopLevelBaseFieldsFromData(objectGraph, marketingItemData), + }; + const upsellBreakout = arcadeUpsell.createUpsellBreakout(objectGraph, marketingItemData, metricsOptions); + metricsHelpersLocation.nextPosition(shelfToken.metricsLocationTracker); + const shelf = new models.Shelf("upsellBreakout"); + shelf.items = [upsellBreakout]; + return shelf; +} +//# sourceMappingURL=editorial-page-upsell-shelf-builder.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-video-clip-shelf-builder.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-video-clip-shelf-builder.js new file mode 100644 index 0000000..b5548db --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/editorial-page-video-clip-shelf-builder.js @@ -0,0 +1,4 @@ +export function buildVideoClipShelf(objectGraph, shelfToken) { + return null; +} +//# sourceMappingURL=editorial-page-video-clip-shelf-builder.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/index.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/index.js new file mode 100644 index 0000000..59dbabe --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-builder/index.js @@ -0,0 +1,83 @@ +import { isNullOrEmpty } from "../../../foundation/json-parsing/server-data"; +import { EditorialShelfType } from "../editorial-page-types"; +import { buildChartShelf } from "./editorial-page-chart-shelf-builder"; +import { buildCollectionShelf } from "./editorial-page-collection-shelf-builder"; +import { buildEngagementShelf } from "./editorial-page-engagement-shelf-builder"; +import { buildGameCenterShelf } from "./editorial-page-game-center-shelf-builder"; +import { buildHeaderShelf } from "./editorial-page-header-shelf-builder"; +import { buildImageShelf } from "./editorial-page-image-shelf-builder"; +import { buildMarkerShelf } from "./editorial-page-marker-shelf-builder"; +import { buildArcadeSeeAllGamesShelf } from "./editorial-page-arcade-see-all-games-shelf-builder"; +import { buildRecommendationsShelf } from "./editorial-page-recommendations-shelf-builder"; +import { buildTagShelf } from "./editorial-page-tag-shelf-builder"; +import { buildTextShelf } from "./editorial-page-text-shelf-builder"; +import { buildUpsellShelf } from "./editorial-page-upsell-shelf-builder"; +import { buildVideoClipShelf } from "./editorial-page-video-clip-shelf-builder"; +import { nextPosition, popLocation, pushContentLocation } from "../../metrics/helpers/location"; +import { addImpressionFields } from "../../metrics/helpers/impressions"; +import { storePlaceholderShelfImpressionMetrics } from "./editorial-page-collection-shelf-builder/editorial-page-collection-shelf-common"; +import { isSome } from "@jet/environment/types/optional"; +export function buildEditorialShelf(objectGraph, pageData, shelfToken) { + let shelf = null; + if (shelfToken.isFirstRender) { + pushContentLocation(objectGraph, shelfToken.metricsImpressionOptions, shelfToken.title); + } + switch (shelfToken.type) { + case EditorialShelfType.ArcadeSeeAllGames: + shelf = buildArcadeSeeAllGamesShelf(objectGraph, shelfToken); + break; + case EditorialShelfType.Collection: + shelf = buildCollectionShelf(objectGraph, shelfToken); + break; + case EditorialShelfType.Chart: + shelf = buildChartShelf(objectGraph, shelfToken); + break; + case EditorialShelfType.Tag: + shelf = buildTagShelf(objectGraph, shelfToken); + break; + case EditorialShelfType.Engagement: + shelf = buildEngagementShelf(objectGraph, shelfToken); + break; + case EditorialShelfType.Text: + shelf = buildTextShelf(objectGraph, shelfToken); + break; + case EditorialShelfType.Image: + shelf = buildImageShelf(objectGraph, shelfToken); + break; + case EditorialShelfType.VideoClip: + shelf = buildVideoClipShelf(objectGraph, shelfToken); + break; + case EditorialShelfType.Header: + shelf = buildHeaderShelf(objectGraph, pageData, shelfToken); + break; + case EditorialShelfType.Recommendations: + shelf = buildRecommendationsShelf(objectGraph, shelfToken); + break; + case EditorialShelfType.GameCenter: + shelf = buildGameCenterShelf(objectGraph, shelfToken); + break; + case EditorialShelfType.Upsell: + shelf = buildUpsellShelf(objectGraph, shelfToken); + break; + case EditorialShelfType.Marker: + shelf = buildMarkerShelf(objectGraph, shelfToken); + break; + default: + break; + } + if (isNullOrEmpty(shelf === null || shelf === void 0 ? void 0 : shelf.items) && isNullOrEmpty(shelf === null || shelf === void 0 ? void 0 : shelf.url)) { + shelf = null; + } + if (shelfToken.isFirstRender) { + popLocation(shelfToken.metricsImpressionOptions.locationTracker); + } + addImpressionFields(objectGraph, shelf, shelfToken.metricsImpressionOptions); + if (shelfToken.isFirstRender) { + nextPosition(shelfToken.metricsImpressionOptions.locationTracker); + } + if (isSome(shelf)) { + storePlaceholderShelfImpressionMetrics(objectGraph, shelf, shelfToken); + } + return shelf; +} +//# sourceMappingURL=index.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-metrics.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-metrics.js new file mode 100644 index 0000000..e1f18ed --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-metrics.js @@ -0,0 +1,51 @@ +import * as serverData from "../../foundation/json-parsing/server-data"; +import * as mediaDataStructure from "../../foundation/media/data-structure"; +import { collectionShelfDisplayStyleFromShelfData } from "./editorial-data-util"; +import { decorateCollectionShelfMetricsOptions } from "./editorial-page-shelf-builder/editorial-page-collection-shelf-builder"; +import { decorateHeroShelfMetricsOptions } from "./editorial-page-shelf-builder/editorial-page-collection-shelf-builder/editorial-page-hero-collection-shelf-builder"; +import { CollectionShelfDisplayStyle, EditorialShelfType } from "./editorial-page-types"; +/** + * Creates the shelf metrics options for a given shelf data item. + * @param objectGraph Current object graph + * @param shelfData The data for the shelf + * @param title The metrics title for the shelf + * @param metricsPageInformation Current metrics page information + * @param metricsLocationTracker Current metrics location tracker + * @returns Built shelf metrics options + */ +export function buildShelfMetricsOptions(objectGraph, shelfData, title, metricsPageInformation, metricsLocationTracker) { + const shelfType = shelfData.type; + const collectionDisplayStyle = collectionShelfDisplayStyleFromShelfData(objectGraph, shelfData); + const shelfMetricsOptions = { + id: serverData.asString(shelfData, "id"), + kind: null, + softwareType: null, + targetType: "swoosh", + title: title, + pageInformation: metricsPageInformation, + locationTracker: metricsLocationTracker, + idType: "shelf_id", + shelfType: shelfType, + recoMetricsData: mediaDataStructure.metricsFromMediaApiObject(shelfData), + canonicalId: serverData.asString(shelfData.meta, "canonicalId"), + }; + switch (shelfType) { + case EditorialShelfType.Collection: + decorateCollectionShelfMetricsOptions(objectGraph, shelfData, shelfMetricsOptions); + switch (collectionDisplayStyle) { + case CollectionShelfDisplayStyle.Hero: + decorateHeroShelfMetricsOptions(objectGraph, shelfMetricsOptions); + break; + default: + break; + } + break; + case EditorialShelfType.Recommendations: + decorateCollectionShelfMetricsOptions(objectGraph, shelfData, shelfMetricsOptions); + break; + default: + break; + } + return shelfMetricsOptions; +} +//# sourceMappingURL=editorial-page-shelf-metrics.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-token.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-token.js new file mode 100644 index 0000000..6857cdb --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-shelf-token.js @@ -0,0 +1,120 @@ +import * as serverData from "../../foundation/json-parsing/server-data"; +import * as mediaAttributes from "../../foundation/media/attributes"; +import * as mediaRelationship from "../../foundation/media/relationships"; +import * as content from "../content/content"; +import { recoMetricsDataForFCData } from "../grouping/shelf-controllers/grouping-shelf-controller-common"; +import { collectionShelfDisplayStyleFromShelfData, extractEditorialClientParams } from "./editorial-data-util"; +import { buildShelfMetricsOptions } from "./editorial-page-shelf-metrics"; +import { GameCenterShelfClientFilter, } from "./editorial-page-types"; +import { isSome } from "@jet/environment"; +/** + * Create the base shelf token to start parsing an editorial page shelf. This will create a new shelf token with the + * base metrics options + * + * @param objectGraph The App Store dependency graph for making native calls and viewing properties + * @param pageId The id of the editorial page this shelf is on. + * @param shelfData The media api data for this specific shelf + * @param isArcadePage Whether this shelf is on the arcade page or not + * @param shelfIndex The index of this shelf on the page, at the time of building + * @param metricsPageInformation The metrics page information for the editorial page + * @param metricsLocationTracker The location tracker for building metrics location information + * @param isSeeAll Whether the shelf is being built as a shelf for a sidepacked See All page. + * @param collectionDisplayStyleOverride A way to override collection display style that is coming from mediaAPI. + */ +export function createBaseShelfToken(objectGraph, pageId, shelfData, isArcadePage, shelfIndex, metricsPageInformation, metricsLocationTracker, isSeeAll = false, collectionDisplayStyle = null) { + const shelfToken = { + id: serverData.asString(shelfData, "id"), + type: shelfData.type, + collectionDisplayStyle: collectionDisplayStyle !== null && collectionDisplayStyle !== void 0 ? collectionDisplayStyle : collectionShelfDisplayStyleFromShelfData(objectGraph, shelfData), + filterOverrides: mediaAttributes.attributeAsArrayOrEmpty(shelfData, "filterOverrides"), + pageId: pageId, + data: shelfData, + presentationHints: {}, + clientIdentifierOverride: null, + isFirstRender: true, + shouldFilter: true, + gamesFilter: gamesFilterFromShelfData(shelfData), + hasExistingContent: false, + title: null, + subtitle: null, + eyebrow: null, + titleArtwork: null, + remainingItems: [], + metricsImpressionOptions: null, + metricsPageInformation: metricsPageInformation, + metricsLocationTracker: metricsLocationTracker, + recoMetricsData: recoMetricsDataForFCData(objectGraph, shelfData), + isDeferring: false, + showOrdinals: false, + ordinalIndex: 1, + isSearchLandingPage: false, + isArcadePage: isArcadePage, + shelfIndex: shelfIndex, + isSeeAll: isSeeAll, + }; + applyBaseShelfTokenTitleValues(objectGraph, shelfData, shelfToken); + return shelfToken; +} +/** + * Apply the values for the title, subtitle, and eyebrow to the shelf token, as well as the impressionOptions + * + * @param objectGraph The App Store dependency graph for making native calls and viewing properties + * @param shelfData The media api data for this specific shelf + * @param shelfToken The shelf token to apply the title values to + */ +export function applyBaseShelfTokenTitleValues(objectGraph, shelfData, shelfToken) { + let title = mediaAttributes.attributeAsString(shelfData, "editorialNotes.name"); + let subtitle = mediaAttributes.attributeAsString(shelfData, "editorialNotes.tagline"); + let eyebrow = mediaAttributes.attributeAsString(shelfData, "editorialNotes.badge"); + let titleArtwork = null; + // 'Similar To' Personalised Shelf + // Check if personalised shelf has a badge-content, if it's got valid content, and the clients support eyebrows and title artwork: + // - Reco shelf title becomes the eyebrow + // - Featured App in badge-content becomes the shelf title, and we add the icon as title artwork + // - No subtitle should be shown + // - Flag to use the eyebrown name for metrics + let wantsEyebrowNameForMetrics = false; + const badgeContent = mediaRelationship.relationshipData(objectGraph, shelfData, "badge-content"); + if (serverData.isDefinedNonNullNonEmpty(badgeContent)) { + eyebrow = objectGraph.loc.uppercased(mediaAttributes.attributeAsString(shelfData, "editorialNotes.name")); + title = mediaAttributes.attributeAsString(badgeContent, "editorialNotes.name"); + titleArtwork = content.iconFromData(objectGraph, badgeContent, { + useCase: 1 /* content.ArtworkUseCase.LockupIconSmall */, + }); + subtitle = null; + wantsEyebrowNameForMetrics = true; + } + if (preprocessor.GAMES_TARGET) { + const editorialClientParams = extractEditorialClientParams(objectGraph, shelfData); + // This flag hides the whole shelf header content altogether + if (isSome(editorialClientParams) && editorialClientParams.suppressName) { + title = null; + subtitle = null; + eyebrow = null; + titleArtwork = null; + } + } + const shelfMetricsOptionsTitle = wantsEyebrowNameForMetrics ? eyebrow : title; + const shelfMetricsOptions = buildShelfMetricsOptions(objectGraph, shelfData, shelfMetricsOptionsTitle, shelfToken.metricsPageInformation, shelfToken.metricsLocationTracker); + shelfToken.title = title; + shelfToken.subtitle = subtitle; + shelfToken.eyebrow = eyebrow; + shelfToken.titleArtwork = titleArtwork; + shelfToken.metricsImpressionOptions = shelfMetricsOptions; +} +function gamesFilterFromShelfData(shelfData) { + const clientFilter = mediaAttributes.attributeAsString(shelfData, "clientFilter"); + let gamesFilter = null; + switch (clientFilter) { + case GameCenterShelfClientFilter.ArcadeGames: + gamesFilter = "arcade"; + break; + case GameCenterShelfClientFilter.AllGames: + gamesFilter = "all"; + break; + default: + break; + } + return gamesFilter; +} +//# sourceMappingURL=editorial-page-shelf-token.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-types.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-types.js new file mode 100644 index 0000000..22daf5f --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-page-types.js @@ -0,0 +1,139 @@ +import { isNothing } from "@jet/environment"; +import * as mediaAttributes from "../../foundation/media/attributes"; +export var EditorialShelfType; +(function (EditorialShelfType) { + EditorialShelfType["ArcadeSeeAllGames"] = "editorial-shelves-arcade-see-all-games"; + EditorialShelfType["Collection"] = "editorial-shelves-collection"; + EditorialShelfType["Chart"] = "editorial-shelves-chart"; + EditorialShelfType["Tag"] = "editorial-shelves-tag"; + EditorialShelfType["Engagement"] = "editorial-shelves-engagement"; + EditorialShelfType["Text"] = "editorial-shelves-text"; + EditorialShelfType["Image"] = "editorial-shelves-image"; + EditorialShelfType["VideoClip"] = "editorial-shelves-video-clip"; + EditorialShelfType["Header"] = "editorial-shelves-header"; + EditorialShelfType["Recommendations"] = "editorial-shelves-recommendation"; + EditorialShelfType["GameCenter"] = "editorial-shelves-game-center"; + EditorialShelfType["Upsell"] = "editorial-shelves-upsell"; + EditorialShelfType["Marker"] = "editorial-shelves-marker"; +})(EditorialShelfType || (EditorialShelfType = {})); +export var CollectionShelfDisplayStyle; +(function (CollectionShelfDisplayStyle) { + CollectionShelfDisplayStyle["Hero"] = "Hero"; + CollectionShelfDisplayStyle["TextOnly"] = "TextOnly"; + CollectionShelfDisplayStyle["TextWithArtwork"] = "TextWithArtwork"; + CollectionShelfDisplayStyle["BrickSmall"] = "BrickSmall"; + CollectionShelfDisplayStyle["BrickMedium"] = "BrickMedium"; + CollectionShelfDisplayStyle["BrickLarge"] = "BrickLarge"; + CollectionShelfDisplayStyle["Charts"] = "Charts"; + CollectionShelfDisplayStyle["EditorialLockupHierarchicalPortrait"] = "EditorialLockupHierarchicalPortrait"; + CollectionShelfDisplayStyle["EditorialLockupHierarchicalRows"] = "EditorialLockupHierarchicalRows"; + CollectionShelfDisplayStyle["EditorialLockupMedium"] = "EditorialLockupMedium"; + CollectionShelfDisplayStyle["EditorialLockupMediumVariant"] = "EditorialLockupMediumVariant"; + CollectionShelfDisplayStyle["EditorialLockupLarge"] = "EditorialLockupLarge"; + CollectionShelfDisplayStyle["EditorialLockupLargeVariant"] = "EditorialLockupLargeVariant"; + CollectionShelfDisplayStyle["LockupMedium"] = "LockupMedium"; + CollectionShelfDisplayStyle["Lockup4Up"] = "Lockup4Up"; + CollectionShelfDisplayStyle["Poster"] = "Poster"; + CollectionShelfDisplayStyle["StorySmall"] = "StorySmall"; + CollectionShelfDisplayStyle["StoryMedium"] = "StoryMedium"; + CollectionShelfDisplayStyle["LockupSmall"] = "LockupSmall"; + CollectionShelfDisplayStyle["LockupLarge"] = "LockupLarge"; + CollectionShelfDisplayStyle["BreakoutLarge"] = "BreakoutLarge"; +})(CollectionShelfDisplayStyle || (CollectionShelfDisplayStyle = {})); +/** + * Returns the limit for a collection shelf to display in a non-See All page. + * @param {CollectionShelfDisplayStyle} displayStyle Collection shelf display style. + * @returns {number | undefined} Number of items to display. + */ +export function displayLimitForCollectionShelf(displayStyle, layoutDirection, shelfToken) { + if (!preprocessor.GAMES_TARGET || shelfToken.isSeeAll) { + return undefined; + } + switch (displayStyle) { + case CollectionShelfDisplayStyle.EditorialLockupLarge: + // "2 Cards" style https://quip-apple.com/qjjZAy4x977f + return layoutDirection === "Condensed" ? 2 : undefined; + case CollectionShelfDisplayStyle.EditorialLockupHierarchicalPortrait: + // "3 Cards" style https://quip-apple.com/qjjZAy4x977f + return 3; + case CollectionShelfDisplayStyle.EditorialLockupMedium: + // "4 Cards (4up)" style https://quip-apple.com/qjjZAy4x977f + return layoutDirection === "Condensed" ? 4 : undefined; + case CollectionShelfDisplayStyle.EditorialLockupHierarchicalRows: + // "4 Cards (Hierarchical)" style https://quip-apple.com/qjjZAy4x977f + return 4; + case CollectionShelfDisplayStyle.Charts: + // "4 Cards (Charts)" style https://quip-apple.com/qjjZAy4x977f + return 6; + case CollectionShelfDisplayStyle.LockupSmall: + // "6 Rows" style https://quip-apple.com/qjjZAy4x977f + return layoutDirection === "Condensed" ? 9 : undefined; + default: + return undefined; + } +} +/** + * Returns the display style override for See All pages. + * @param {CollectionShelfDisplayStyle} displayStyle Collection shelf display style. + * @returns {number | undefined} Number of items to display. + */ +export function collectionDisplayStyleOverride(displayStyle) { + if (!preprocessor.GAMES_TARGET || isNothing(displayStyle)) { + return null; + } + switch (displayStyle) { + // These shelves should maintain their display style in See All pages. + case CollectionShelfDisplayStyle.BrickSmall: + case CollectionShelfDisplayStyle.LockupMedium: + return displayStyle; + // All other shelves will display in EditorialLockupLarge display style in See All pages. + default: + return CollectionShelfDisplayStyle.EditorialLockupLarge; + } +} +export var MarkerShelfKind; +(function (MarkerShelfKind) { + MarkerShelfKind["QuickLinks"] = "QuickLinks"; +})(MarkerShelfKind || (MarkerShelfKind = {})); +export var CollectionShelfLayoutDirection; +(function (CollectionShelfLayoutDirection) { + CollectionShelfLayoutDirection["Vertical"] = "Vertical"; + CollectionShelfLayoutDirection["Horizontal"] = "Horizontal"; + CollectionShelfLayoutDirection["Condensed"] = "Condensed"; +})(CollectionShelfLayoutDirection || (CollectionShelfLayoutDirection = {})); +export function collectionShelfLayoutDirection(shelfToken) { + const layoutDirection = mediaAttributes.attributeAsString(shelfToken.data, "layoutDirection"); + if (layoutDirection === CollectionShelfLayoutDirection.Horizontal) { + return CollectionShelfLayoutDirection.Horizontal; + } + if (layoutDirection === CollectionShelfLayoutDirection.Condensed) { + return CollectionShelfLayoutDirection.Condensed; + } + // Make default one as vertical for backward compatibility when code used to check `=== "Horizontal"`. + return CollectionShelfLayoutDirection.Vertical; +} +export var CollectionShelfFilterOverride; +(function (CollectionShelfFilterOverride) { + CollectionShelfFilterOverride["ShowInstalled"] = "ShowInstalled"; + CollectionShelfFilterOverride["ShowAllPlatforms"] = "ShowAllPlatforms"; + CollectionShelfFilterOverride["ShowOnlyPreorder"] = "ShowOnlyPreorder"; +})(CollectionShelfFilterOverride || (CollectionShelfFilterOverride = {})); +export var GameCenterShelfClientFilter; +(function (GameCenterShelfClientFilter) { + GameCenterShelfClientFilter["AllGames"] = "AllGames"; + GameCenterShelfClientFilter["ArcadeGames"] = "ArcadeGames"; +})(GameCenterShelfClientFilter || (GameCenterShelfClientFilter = {})); +export var GameCenterShelfKind; +(function (GameCenterShelfKind) { + GameCenterShelfKind["FriendsArePlaying"] = "FriendsArePlaying"; + GameCenterShelfKind["ContinuePlaying"] = "ContinuePlaying"; +})(GameCenterShelfKind || (GameCenterShelfKind = {})); +export var UpsellShelfPlacement; +(function (UpsellShelfPlacement) { + UpsellShelfPlacement["ArcadeTabHeader"] = "ArcadeTabHeader"; +})(UpsellShelfPlacement || (UpsellShelfPlacement = {})); +export var UpsellShelfServiceType; +(function (UpsellShelfServiceType) { + UpsellShelfServiceType["Arcade"] = "Arcade"; +})(UpsellShelfServiceType || (UpsellShelfServiceType = {})); +//# sourceMappingURL=editorial-page-types.js.map
\ No newline at end of file diff --git a/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-shelf-collection-page-utils.js b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-shelf-collection-page-utils.js new file mode 100644 index 0000000..6544691 --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/common/editorial-pages/editorial-shelf-collection-page-utils.js @@ -0,0 +1,120 @@ +import { isSome, unwrapOptional as unwrap } from "@jet/environment/types/optional"; +import { GenericPage, Shelf, PageHeader } from "../../api/models"; +import { makeEditorialShelfCollectionPageIntent, } from "../../api/intents/editorial/editorial-shelf-collection-page-intent"; +import { Request, defaultAdditionalPlatformsForClient } from "../../foundation/media/data-fetching"; +import { dataFromDataContainer } from "../../foundation/media/data-structure"; +import { attributeAsString } from "../../foundation/media/attributes"; +import { isDefinedNonNullNonEmpty } from "../../foundation/json-parsing/server-data"; +import { metricsPageInformationFromMediaApiResponse, addMetricsEventsToPageWithInformation, } from "../../common/metrics/helpers/page"; +import { newLocationTracker } from "../../common/metrics/helpers/location"; +import { createBaseShelfToken } from "../../common/editorial-pages/editorial-page-shelf-token"; +import { buildEditorialShelf } from "../../common/editorial-pages/editorial-page-shelf-builder"; +import { newPageRefreshControllerFromResponse, pageRefreshPolicyForController, } from "../../common/refresh/page-refresh-controller"; +import { shouldFetchCustomAttributes } from "../product-page/product-page-variants"; +import { prepareMAPIRequest } from "./editorial-page-controller-util"; +import { generateRoutes } from "../util/generate-routes"; +import { setPreviewPlatform } from "../preview-platform"; +import { makeGamesPageHeader } from "../../gameservicesui/src/editorial-page/editorial-component-builder"; +import { collectionShelfDisplayStyleFromShelfData } from "./editorial-data-util"; +import { collectionDisplayStyleOverride } from "./editorial-page-types"; +import { shouldUsePrerenderedIconArtwork } from "../content/content"; +// MARK: - `EditorialShelfCollectionPageIntentController` URL Building +const { routes: routesWithoutPlatformSegment, makeCanonicalUrl: makeCanonicalUrlWithoutPlatformSegment } = generateRoutes(makeEditorialShelfCollectionPageIntent, "/collections/{id}"); +const { routes: routesWithPlatformSegment, makeCanonicalUrl: makeCanonicalUrlWithPlatformSegment } = generateRoutes(makeEditorialShelfCollectionPageIntent, "/{platform}/collections/{id}"); +export function editorialShelfCollectionPageRoutes(objectGraph) { + return [...routesWithoutPlatformSegment(objectGraph), ...routesWithPlatformSegment(objectGraph)]; +} +export function makeEditorialShelfCollectionPageURL(objectGraph, intent) { + if (intent.platform) { + return makeCanonicalUrlWithPlatformSegment(objectGraph, intent); + } + else { + return makeCanonicalUrlWithoutPlatformSegment(objectGraph, intent); + } +} +// MARK: - Media API Request Building +export function defaultRequestAttributes(objectGraph) { + const attributes = [ + "editorialArtwork", + "editorialVideo", + "isAppleWatchSupported", + "requiredCapabilities", + "expectedReleaseDateDisplayFormat", + "showExpectedReleaseDate", + "badge-content", + "compatibilityControllerRequirement", + ]; + if (objectGraph.appleSilicon.isSupportEnabled) { + attributes.push("macRequiredCapabilities"); + } + if (objectGraph.client.isMac) { + attributes.push("hasMacIPAPackage"); + } + if (objectGraph.bag.enableUpdatedAgeRatings) { + attributes.push("ageRating"); + } + if (shouldUsePrerenderedIconArtwork(objectGraph)) { + attributes.push("iconArtwork"); + } + return attributes; +} +/** + * Creates a {@linkcode Request} to fetch a single `editorial-shelves-collection` item by {@linkcode id} + */ +export function makeEditorialShelfCollectionPageRequest(objectGraph, intent) { + const request = new Request(objectGraph, `/v1/editorial/${intent.storefront}`).withIdOfType(intent.id, "editorial-shelves-collection"); + request + .includingAgeRestrictions() + .includingAdditionalPlatforms(defaultAdditionalPlatformsForClient(objectGraph)) + .includingAttributes(defaultRequestAttributes(objectGraph)) + .usingCustomAttributes(shouldFetchCustomAttributes(objectGraph)); + if (objectGraph.client.isWatch) { + request.addingRelationshipLimit("contents", 3); + } + request + .includingRelationships(["contents"]) + .includingScopedRelationships("editorial-pages", ["primary-contents"]) + .includingAssociateKeys("editorial-shelves-collection:contents", ["editorial-cards"]); + prepareMAPIRequest(objectGraph, request); + setPreviewPlatform(objectGraph, request); + return request; +} +// MARK: - Editorial Shelves Collection Page Rendering +export function renderEditorialShelfCollectionPage(objectGraph, data) { + var _a; + const shelfData = dataFromDataContainer(objectGraph, data); + if (!isDefinedNonNullNonEmpty(shelfData)) { + return null; + } + const metricsPageInformation = metricsPageInformationFromMediaApiResponse(objectGraph, "Room", shelfData.id, data); + const metricsPageLocationTracker = newLocationTracker(); + const pageRefreshController = newPageRefreshControllerFromResponse(data); + const collectionDisplayStyle = collectionShelfDisplayStyleFromShelfData(objectGraph, shelfData); + const shelfToken = createBaseShelfToken(objectGraph, undefined, shelfData, false, 0, metricsPageInformation, metricsPageLocationTracker, preprocessor.GAMES_TARGET, collectionDisplayStyleOverride(collectionDisplayStyle)); + const shelves = []; + const shelf = unwrap(buildEditorialShelf(objectGraph, undefined, shelfToken)); + shelf.title = null; + shelf.eyebrow = null; + shelf.isHorizontal = false; + const headerTitle = attributeAsString(shelfData, "editorialNotes.name"); + if (isSome(headerTitle)) { + // There must be a title to create a pageHeader. + const headerShelf = new Shelf("pageHeader"); + headerShelf.id = "shelf_page_header"; + let pageHeader; + if (preprocessor.GAMES_TARGET) { + pageHeader = makeGamesPageHeader(shelfToken, headerTitle, shelf.items, (_a = attributeAsString(shelfData, "editorialNotes.tagline")) !== null && _a !== void 0 ? _a : undefined); + } + else { + pageHeader = new PageHeader(null, headerTitle, attributeAsString(shelfData, "editorialNotes.tagline")); + } + headerShelf.items = [pageHeader]; + shelves.push(headerShelf); + } + shelves.push(shelf); + const page = new GenericPage(shelves); + page.pageRefreshPolicy = pageRefreshPolicyForController(objectGraph, pageRefreshController); + addMetricsEventsToPageWithInformation(objectGraph, page, metricsPageInformation); + return page; +} +//# sourceMappingURL=editorial-shelf-collection-page-utils.js.map
\ No newline at end of file |