diff options
Diffstat (limited to 'node_modules/@jet-app/app-store/tmp/src/foundation/media/data-fetching.js')
| -rw-r--r-- | node_modules/@jet-app/app-store/tmp/src/foundation/media/data-fetching.js | 631 |
1 files changed, 631 insertions, 0 deletions
diff --git a/node_modules/@jet-app/app-store/tmp/src/foundation/media/data-fetching.js b/node_modules/@jet-app/app-store/tmp/src/foundation/media/data-fetching.js new file mode 100644 index 0000000..445f42f --- /dev/null +++ b/node_modules/@jet-app/app-store/tmp/src/foundation/media/data-fetching.js @@ -0,0 +1,631 @@ +import { isNothing, isSome } from "@jet/environment/types/optional"; +import * as serverData from "../json-parsing/server-data"; +import * as client from "../wrappers/client"; +export function allPlatforms(objectGraph, platformsToExclude) { + const platforms = new Set(); + platforms.add("iphone"); + platforms.add("ipad"); + platforms.add("appletv"); + platforms.add("mac"); + platforms.add("watch"); + if (objectGraph.client.isVision || objectGraph.bag.enableVisionPlatform) { + platforms.add("realityDevice"); + } + if (isSome(platformsToExclude)) { + for (const platform of platformsToExclude) { + platforms.delete(platform); + } + } + return Array.from(platforms); +} +export function defaultPlatformForClient(objectGraph) { + if (objectGraph.client.isCompanionVisionApp) { + // The Vision companion app always prefers visionOS assets + return "realityDevice"; + } + switch (objectGraph.client.deviceType) { + case "phone": + return "iphone"; + case "pad": + return "ipad"; + case "tv": + return "appletv"; + case "mac": + return "mac"; + case "watch": + return "watch"; + case "vision": + return "realityDevice"; + case "web": + return "web"; + default: + return null; + } +} +/** + * Returns the layout size controlling the number of rows to display. + * @param {AppStoreObjectGraph} objectGraph Object graph to get the client device type. + * @returns {number} Layout size. + */ +export function defaultLayoutSize(objectGraph) { + return objectGraph.client.isPhone ? 2 : 1; +} +/** + * Returns the sparse count controlling the number of shelves to hydrate. + * @param {AppStoreObjectGraph} objectGraph Object graph to get the client device type. + * @returns {number} Sparse count. + */ +export function defaultSparseCountForClient(objectGraph) { + switch (objectGraph.client.deviceType) { + case "phone": + return 4; + case "pad": + return 5; + case "tv": + return 6; + case "mac": + return 5; + case "watch": + return 10; + default: + return null; + } +} +/** + * Returns the sparse limit controlling the number of items to hydrate per shelve. + * @param {AppStoreObjectGraph} objectGraph Object graph to get the client device type. + * @returns {number} Sparse limit. + */ +export function defaultSparseLimitForClient(objectGraph) { + switch (objectGraph.client.deviceType) { + case "phone": + return 9; + case "pad": + return 12; + case "tv": + return 15; + case "mac": + return 15; + case "watch": + return 3; + case "web": + return 12; + default: + return null; + } +} +/** + * Get the list of all platforms excluding the current platform + * @returns {Platform[]} + */ +export function defaultAdditionalPlatformsForClient(objectGraph) { + switch (objectGraph.host.clientIdentifier) { + case "com.apple.TVAppStore.AppStoreTopShelfExtension": + case "com.apple.Arcade.ArcadeTopShelfExtension": + case "com.apple.AppStore.Widgets": + // Skip additional platforms for top shelf extension due to memory constraint. + return []; + default: { + const currentPlatform = defaultPlatformForClient(objectGraph); + return allPlatforms(objectGraph, isSome(currentPlatform) ? new Set([currentPlatform]) : undefined); + } + } +} +/** + * Get the product page reviews limit for a client. + * @returns {number} The limit to use. + */ +export function defaultProductPageReviewsLimitForClient(objectGraph) { + switch (objectGraph.client.deviceType) { + case "phone": + return 6; + case "pad": + return 10; + case "mac": + return 12; + case "vision": + return 10; + default: + return 8; + } +} +/// Returns the context param to use for a given grouping request. +/// This is leveraged for switching grouping tab root in specific configurations. +export function defaultGroupingContextForClient(objectGraph) { + let context = null; + if (objectGraph.host.clientIdentifier === client.messagesIdentifier) { + // Messages Grouping (iOS) + context = "messages"; + } + else if (objectGraph.host.clientIdentifier === client.watchIdentifier) { + // Bridge App Store (iOS) + context = "watch"; + } + else if (objectGraph.client.isWatch && objectGraph.client.isTinkerWatch) { + // Tinker App Store (watchOS) + context = "tinker"; + } + return context; +} +// Nothing on the App Store is rated 1000+, so a value this high essentially +// indicates that content restrictions are disabled. +export const ageRestrictionsDisabledThreshold = 1000; +export class Request { + constructor(objectGraph, param, enableMixedCatalog, supplementaryMetadataAssociations) { + var _a; + /// The resource types used in a mixed contents call + this.contentsResourceTypes = new Set(); + /// The ID(s) associated with the resource type + this.ids = new Set(); + /// IDs associated with specific resource types, used for mixed catalog requests + this.idsByResourceType = new Map(); + /// The original ordering of the ids in this reqeust if there is a mixed catalog request + this.originalOrdering = []; + this.relationshipIncludes = new Set(); + // Contents of `extend` param + this.attributeIncludes = new Set(); + this.platform = null; + /// The paths to additional metadata that need to be fetched for mixed media requests + this.supplementaryMetadataAssociations = []; + this.additionalPlatforms = new Set(); + this.additionalQuery = {}; + this.relationshipLimits = {}; + this.searchTerm = null; + this.searchTypes = []; + /// Whether we are searching watch or messages store. + this.context = null; + /// Whether or not to use custom extend attributes, instead of using `attributeIncludes` as-is. + this.useCustomAttributes = false; + /// An optional country code override for constructing the URL. Used in very specific regulatory scenarios where the bag country code cannot be relied upon. + this.countryCodeOverride = undefined; + this.objectGraph = objectGraph; + this.platform = defaultPlatformForClient(objectGraph); + this.isMixedMediaRequest = enableMixedCatalog !== null && enableMixedCatalog !== void 0 ? enableMixedCatalog : false; + this.supplementaryMetadataAssociations = supplementaryMetadataAssociations !== null && supplementaryMetadataAssociations !== void 0 ? supplementaryMetadataAssociations : []; + this.includeAppBinaryTraitsAttribute = objectGraph.client.isiOS; + // By default, the `platform` for web defaults to whatever the `activeIntent` is (e.g. "mac"), + // but this can be overridden when calling `setPreviewPlatform` with the request, which + // will set the `platform` to `web` and `previewPlatform` will be the `activeIntent` platform. + if ((_a = objectGraph.activeIntent) === null || _a === void 0 ? void 0 : _a.platform) { + this.platform = objectGraph.activeIntent.platform; + } + if (serverData.isNullOrEmpty(param)) { + return; + } + if (typeof param === "string") { + this.href = param; + } + else if (Array.isArray(param)) { + this.withDataItems(param, supplementaryMetadataAssociations, enableMixedCatalog); + } + } + /** + * Adds a data object to an idsByResourceType mapping. + * @param data The data object + * @returns An updated {resource-type: IDs} map, which includes the data object + */ + addDataToIDsByResourceType(data) { + const resourceType = data.type; + const id = data.id; + let ids = this.idsByResourceType.get(resourceType); + if (isNothing(ids)) { + ids = new Set(); + } + ids.add(id); + this.idsByResourceType.set(resourceType, ids); + } + forType(type) { + this.resourceType = type; + return this; + } + /** + * This method is used to add data items to the request. It is used to build the request for the mixed catalog / catalog + * + * @param dataItems The data items to add to the request + * @param supplementaryMetadataAssociations The metadata paths to add to the request + * @param enableMixedCatalog Whether to allow mixed catalog requests + * @returns The modified Request + */ + withDataItems(dataItems, supplementaryMetadataAssociations, enableMixedCatalog) { + if (dataItems.length === 0) { + return this; + } + this.isMixedMediaRequest = this.isMixedMediaRequest || (enableMixedCatalog !== null && enableMixedCatalog !== void 0 ? enableMixedCatalog : false); + for (const data of dataItems) { + // Track all IDs in a single set, for the case where we use the contents endpoint. + this.ids.add(data.id); + // Track all IDs by resource type, for either the case where we ultimately have just + // one resource type, or where we used the mixed catalog endpoint. + this.addDataToIDsByResourceType(data); + // If we have any additional metadata paths that need fetching, we now add them + // as additional resource types for the mixed catalog endpoint. + if (isSome(enableMixedCatalog) && + enableMixedCatalog && + isSome(supplementaryMetadataAssociations) && + supplementaryMetadataAssociations.length > 0) { + for (const association of supplementaryMetadataAssociations) { + const metadataItems = extractMetaAssociationFromData(association, data); + if (isSome(metadataItems) && metadataItems.length > 0) { + metadataItems.forEach((metadataItem) => { + this.addDataToIDsByResourceType(metadataItem); + }); + } + } + } + } + // Now that we have collated all IDs and resource types, we can assign them to different + // properties depending on the number of resource types we need. + if (this.idsByResourceType.size === 1) { + // We only have one list of IDs for a single resource type, so we just take the first one + this.resourceType = this.idsByResourceType.keys().next().value; + this.isMixedMediaRequest = false; + } + else if (this.idsByResourceType.size > 1 && !this.isMixedMediaRequest) { + this.resourceType = "contents"; + this.contentsResourceTypes = new Set(Array.from(this.idsByResourceType.keys())); + } + this.originalOrdering.push(...[...dataItems]); + return this; + } + /** + * Add a single id to this request, this should only be used when fetching a single resource + * @param id The single ID to add to the request + * @param type The type of the resource + * @returns The modified Request + */ + withIdOfType(id, type) { + return this.withDataItems([{ id, type }]); + } + /** + * Add a list of ids to this request, this will add these ids to the mapping of resource types + * @param ids The IDs to add to the request + * @param type The type of the resource + * @returns The modified Request + */ + withIdsOfType(ids, type) { + return this.withDataItems(ids.map((id) => ({ id, type }))); + } + includingRelationships(relationships) { + for (const relationship of relationships) { + this.relationshipIncludes.add(relationship); + } + return this; + } + includingScopedRelationships(scopedDataType, relationshipsToAdd) { + // Lazy init top-level property + if (!this.scopedRelationshipIncludes) { + this.scopedRelationshipIncludes = new Map(); + } + // Retrieve existing scoped relationship. Lazy init if needed. + let scopedRelationship = this.scopedRelationshipIncludes.get(scopedDataType); + if (!scopedRelationship) { + scopedRelationship = new Set(); + } + // Update + for (const newRelationship of relationshipsToAdd) { + scopedRelationship.add(newRelationship); + } + this.scopedRelationshipIncludes.set(scopedDataType, scopedRelationship); + return this; + } + includingMetaKeys(scopedDataType, keysToAdd) { + // Lazy init top-level property + if (!this.metaIncludes) { + this.metaIncludes = new Map(); + } + // Retrieve existing inclusion. Lazy init if needed. + let scopedMeta = this.metaIncludes.get(scopedDataType); + if (!scopedMeta) { + scopedMeta = new Set(); + } + // Update + for (const newKey of keysToAdd) { + scopedMeta.add(newKey); + } + this.metaIncludes.set(scopedDataType, scopedMeta); + return this; + } + includingViews(viewsToAdd) { + // Lazy init top-level property + if (!this.viewsIncludes) { + this.viewsIncludes = new Set(); + } + for (const view of viewsToAdd) { + this.viewsIncludes.add(view); + } + return this; + } + includingKindsKeys(scopedDataType, keysToAdd) { + // Lazy init top-level property + if (!this.kindIncludes) { + this.kindIncludes = new Map(); + } + // Retrieve existing inclusion. Lazy init if needed. + let scopedMeta = this.kindIncludes.get(scopedDataType); + if (!scopedMeta) { + scopedMeta = new Set(); + } + // Update + for (const newKey of keysToAdd) { + scopedMeta.add(newKey); + } + this.kindIncludes.set(scopedDataType, scopedMeta); + return this; + } + includingAssociateKeys(scopedDataType, keysToAdd) { + // Lazy init top-level property + if (!this.associateIncludes) { + this.associateIncludes = new Map(); + } + // Retrieve existing inclusion. Lazy init if needed. + let scopedAssociate = this.associateIncludes.get(scopedDataType); + if (!scopedAssociate) { + scopedAssociate = new Set(); + } + // Update + for (const newKey of keysToAdd) { + scopedAssociate.add(newKey); + } + this.associateIncludes.set(scopedDataType, scopedAssociate); + return this; + } + /** + * Include the relationships needed for an upsell. + * @param requiresScopedInclude A flag indicating whether the include should be "scoped". This will need to be the + * case when the relationships we are including is on a request for a separate primary resource type. For example, + * if we are looking to have the upsell relationship included in an EI (Today card, for example), this needs to be + * scoped. However, if we are fetching a grouping directly and need the upsell included, this should *not* be scoped. + */ + includingRelationshipsForUpsell(requiresScopedRelationshipInclude) { + const relationship = "marketing-items"; + if (requiresScopedRelationshipInclude) { + // Lazy init top-level property + if (!this.scopedRelationshipIncludes) { + this.scopedRelationshipIncludes = new Map(); + } + // Retrieve existing scoped relationship. Lazy init if needed. + let scopedRelationship = this.scopedRelationshipIncludes.get("editorial-items"); + if (!scopedRelationship) { + scopedRelationship = new Set(); + } + // Update + scopedRelationship.add(relationship); + this.scopedRelationshipIncludes.set("editorial-items", scopedRelationship); + } + else { + this.relationshipIncludes.add(relationship); + } + // In order to get metrics metadata stiched in to the marketing item relationship, we have to include it in our + // request. + if (relationship === "marketing-items") { + if (!this.metaIncludes) { + this.metaIncludes = new Map(); + } + // Retrieve existing inclusion. Lazy init if needed. + let scopedMeta = this.metaIncludes.get("marketing-items"); + if (!scopedMeta) { + scopedMeta = new Set(); + } + scopedMeta.add("metrics"); + this.metaIncludes.set("marketing-items", scopedMeta); + } + return this; + } + includingAttributes(attributes) { + for (const attribute of attributes) { + this.attributeIncludes.add(attribute); + } + return this; + } + includingScopedAttributes(resourceType, attributesToAdd) { + // Lazy init top-level property + if (!this.scopedAttributeIncludes) { + this.scopedAttributeIncludes = new Map(); + } + // Retrieve existing scoped relationship. Lazy init if needed. + let attributesForResourceType = this.scopedAttributeIncludes.get(resourceType); + if (!attributesForResourceType) { + attributesForResourceType = new Set(); + } + // Update + for (const attribute of attributesToAdd) { + attributesForResourceType.add(attribute); + } + this.scopedAttributeIncludes.set(resourceType, attributesForResourceType); + return this; + } + /** + * Adds an age restriction to the request. ManagedConfiguration provides + * this value on the client, which maps to JRPurpleRating.clientIdentifier. + * + * @returns {Request} The updated request + */ + includingAgeRestrictions() { + const maxAppContentRating = this.objectGraph.client.maxAppContentRating; + if (maxAppContentRating < ageRestrictionsDisabledThreshold) { + this.ageRestriction = maxAppContentRating; + } + return this; + } + includingAdditionalPlatforms(additionalPlatforms) { + for (const platform of additionalPlatforms) { + this.additionalPlatforms.add(platform); + } + return this; + } + includingScopedAvailableIn(resourceType, valuesToAdd) { + // Lazy init top-level property + if (!this.scopedAvailableInIncludes) { + this.scopedAvailableInIncludes = new Map(); + } + // Retrieve existing scoped relationship. Lazy init if needed. + let valuesForResourceType = this.scopedAvailableInIncludes.get(resourceType); + if (!valuesForResourceType) { + valuesForResourceType = new Set(); + } + // Update + for (const value of valuesToAdd) { + valuesForResourceType.add(value); + } + this.scopedAvailableInIncludes.set(resourceType, valuesForResourceType); + return this; + } + /** + * Include the sparse limit needed for a specific resource type. + * @param {media.Type} resourceType Resource type to use for the sparse limit. + * @param {number} value Value to set as the sparse limit. + * @returns {Request} Updated request. + */ + includingScopedSparseLimit(resourceType, value) { + // Lazy init top-level property + if (!this.scopedSparseLimit) { + this.scopedSparseLimit = new Map(); + } + this.scopedSparseLimit.set(resourceType, value); + return this; + } + addingQuery(key, value) { + if (isSome(value)) { + this.additionalQuery[key] = value; + } + else { + delete this.addingQuery[key]; + } + return this; + } + /** + * @param query The additional query values to add + * @returns The modified Reqeust + */ + addingQueryValues(query) { + this.additionalQuery = { + ...this.addingQuery, + ...query, + }; + return this; + } + addingRelationshipLimit(relationship, limit) { + this.relationshipLimits[relationship] = limit; + return this; + } + withSearchTerm(term) { + this.searchTerm = term; + return this; + } + searchingOverTypes(types) { + for (const type of types) { + this.searchTypes.push(type); + } + return this; + } + addingContext(context) { + this.context = context; + return this; + } + includingMacOSCompatibleIOSAppsWhenSupported(verifiedBadgeOnly = false) { + if (this.objectGraph.appleSilicon.isSupportEnabled) { + if (!verifiedBadgeOnly) { + this.enablingFeature("macOSCompatibleIOSApps"); + } + this.includingScopedAttributes("apps", ["isVerifiedForAppleSiliconMac"]); + } + return this; + } + /// Mark a request to include (or exclude) appBinaryTraits attributes. + includingAppBinaryTraitsAttribute(includeAppBinaryTraitsAttribute = true) { + this.includeAppBinaryTraitsAttribute = includeAppBinaryTraitsAttribute; + return this; + } + /** + * Mark a request to use custom attributes. + * This triggers usage of `customXYZ` extend attributes in url-builder for specific extend params + * e.g. `artwork`, `customArtwork`. + */ + usingCustomAttributes(useCustomAttributes) { + this.useCustomAttributes = useCustomAttributes; + return this; + } + alwaysUseIdsAsQueryParam(value) { + this.useIdsAsQueryParam = value; + return this; + } + attributingTo(canonicalUrl) { + this.canonicalUrl = canonicalUrl; + return this; + } + withFilter(type, value) { + this.filterType = type; + this.filterValue = value; + return this; + } + withLimit(limit) { + this.limit = limit; + return this; + } + withSparseLimit(sparseLimit) { + if (sparseLimit !== null) { + this.sparseLimit = sparseLimit; + } + return this; + } + withSparseCount(sparseCount) { + if (sparseCount !== null) { + this.sparseCount = sparseCount; + } + return this; + } + enablingFeature(feature) { + if (!this.enabledFeatures) { + this.enabledFeatures = []; + } + this.enabledFeatures.push(feature); + return this; + } + enablingFeatures(features) { + if (!this.enabledFeatures) { + this.enabledFeatures = []; + } + this.enabledFeatures.push(...features); + return this; + } + /** + * Limit the request to include only certain fields. + * This should only be used in very select use-cases, where: + * - There is no possibility of data being used for other purposes, e.g. sidpack + * - All consumer of this data use it in the same narrow scope, e.g. requesting a set of icons for displaying without metadata only. + * @param fields Set of fields to limit to + */ + asPartialResponseLimitedToFields(fields) { + this.fields = fields; + return this; + } + includesResourceType(resourceType) { + if (this.resourceType === resourceType) { + return true; + } + if (serverData.isDefinedNonNull(this.contentsResourceTypes)) { + return this.contentsResourceTypes.has(resourceType); + } + return false; + } + withCountryCodeOverride(countryCodeOverride) { + this.countryCodeOverride = countryCodeOverride; + return this; + } +} +/** + * Extracts the metadata association from the data. + * @param association The association to extract + * @param data The data to extract from + */ +export function extractMetaAssociationFromData(association, data) { + if (serverData.isNullOrEmpty(data)) { + return null; + } + const associationData = serverData.asArrayOrEmpty(data, `meta.associations.${association}.data`); + if (isNothing(associationData)) { + return null; + } + return [...associationData]; +} +//# sourceMappingURL=data-fetching.js.map
\ No newline at end of file |