storemeta 0.1.0

package/dist/platforms/apple/client.js

@@ -0,0 +1,109 @@
+import { StoremetaError } from "../../cli/errors.js";
+import { createAppleJwtToken } from "../../auth/apple/jwt.js";
+const APP_STORE_CONNECT_API_BASE_URL = "https://api.appstoreconnect.apple.com/v1";
+async function createAppStoreConnectErrorMessage(response) {
+    const fallbackMessage = `App Store Connect API request failed with ${response.status} ${response.statusText}`;
+    try {
+        const errorDocument = (await response.json());
+        const firstError = errorDocument.errors?.[0];
+        if (firstError === undefined) {
+            return fallbackMessage;
+        }
+        const detailParts = [
+            firstError.code,
+            firstError.title,
+            firstError.detail,
+        ].filter((part) => part !== undefined && part.trim().length > 0);
+        if (detailParts.length === 0) {
+            return fallbackMessage;
+        }
+        return `${fallbackMessage}: ${detailParts.join(" - ")}`;
+    }
+    catch {
+        return fallbackMessage;
+    }
+}
+export class AppStoreConnectClient {
+    credentials;
+    env;
+    constructor(credentials, env = process.env) {
+        this.credentials = credentials;
+        this.env = env;
+    }
+    async request(path, options = {}) {
+        const jwt = await createAppleJwtToken(this.credentials, this.env);
+        const requestUrl = path.startsWith("https://") || path.startsWith("http://")
+            ? path
+            : `${APP_STORE_CONNECT_API_BASE_URL}${path}`;
+        let response;
+        try {
+            response = await fetch(requestUrl, {
+                method: options.method ?? "GET",
+                headers: {
+                    Authorization: `Bearer ${jwt}`,
+                    ...options.headers,
+                },
+                body: options.body,
+            });
+        }
+        catch (cause) {
+            throw new StoremetaError("API_ERROR", "App Store Connect API request failed before a response was received", { cause });
+        }
+        if (!response.ok) {
+            throw new StoremetaError("API_ERROR", await createAppStoreConnectErrorMessage(response));
+        }
+        return response;
+    }
+    async requestJson(path, options = {}) {
+        const response = await this.request(path, {
+            ...options,
+            headers: {
+                Accept: "application/json",
+                ...options.headers,
+            },
+        });
+        return (await response.json());
+    }
+}
+export function createAppStoreConnectClient(credentials, env = process.env) {
+    return new AppStoreConnectClient(credentials, env);
+}
+export async function postAppStoreConnectJson(client, path, body) {
+    return client.requestJson(path, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(body),
+    });
+}
+export async function patchAppStoreConnectJson(client, path, body) {
+    return client.requestJson(path, {
+        method: "PATCH",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(body),
+    });
+}
+export async function requestAllAppStoreConnectPages(client, path) {
+    const resources = [];
+    const seenPaths = new Set();
+    let currentPath = path;
+    while (currentPath !== undefined) {
+        if (seenPaths.has(currentPath)) {
+            throw new StoremetaError("API_ERROR", `App Store Connect pagination loop detected at ${currentPath}`);
+        }
+        seenPaths.add(currentPath);
+        const response = await client.requestJson(currentPath);
+        resources.push(...response.data);
+        if (response.data.length === 0) {
+            break;
+        }
+        currentPath =
+            response.links?.next !== undefined && response.links.next.length > 0
+                ? response.links.next
+                : undefined;
+    }
+    return resources;
+}

package/dist/platforms/apple/metadata/pull.js

@@ -0,0 +1,120 @@
+import { normalizeLocaleCode } from "../../../locales/normalize.js";
+import { writeMetadataFile } from "../../../writers/write-metadata.js";
+import { requestAllAppStoreConnectPages } from "../client.js";
+const EDITABLE_APP_STORE_STATES = [
+    "PREPARE_FOR_SUBMISSION",
+    "READY_FOR_REVIEW",
+    "INVALID_BINARY",
+    "WAITING_FOR_REVIEW",
+    "IN_REVIEW",
+    "ACCEPTED",
+    "WAITING_FOR_EXPORT_COMPLIANCE",
+    "PENDING_DEVELOPER_RELEASE",
+    "REJECTED",
+    "METADATA_REJECTED",
+    "DEVELOPER_REJECTED",
+];
+function getAppleVersionCreatedTimestamp(version) {
+    const createdDate = version.attributes?.createdDate;
+    if (createdDate === undefined) {
+        return Number.NEGATIVE_INFINITY;
+    }
+    const timestamp = Date.parse(createdDate);
+    return Number.isNaN(timestamp) ? Number.NEGATIVE_INFINITY : timestamp;
+}
+function sortAppleVersionsByPriority(versions) {
+    return [...versions].sort((left, right) => {
+        const createdDateOrder = getAppleVersionCreatedTimestamp(right) - getAppleVersionCreatedTimestamp(left);
+        if (createdDateOrder !== 0) {
+            return createdDateOrder;
+        }
+        return right.id.localeCompare(left.id);
+    });
+}
+export function selectPreferredAppleAppStoreVersion(versions) {
+    const sortedVersions = sortAppleVersionsByPriority(versions);
+    const iosVersions = sortedVersions.filter((version) => version.attributes?.platform === "IOS");
+    const candidateVersions = iosVersions.length > 0 ? iosVersions : sortedVersions;
+    const editableVersion = candidateVersions.find((version) => {
+        const state = version.attributes?.appStoreState;
+        return state !== undefined && EDITABLE_APP_STORE_STATES.includes(state);
+    });
+    if (editableVersion !== undefined) {
+        return editableVersion;
+    }
+    const liveVersion = candidateVersions.find((version) => version.attributes?.appStoreState === "READY_FOR_SALE");
+    if (liveVersion !== undefined) {
+        return liveVersion;
+    }
+    return candidateVersions[0];
+}
+export async function fetchAppleAppInfoLocalizations(client, appId) {
+    const appInfos = await requestAllAppStoreConnectPages(client, `/apps/${encodeURIComponent(appId)}/appInfos`);
+    if (appInfos.length === 0) {
+        return [];
+    }
+    return requestAllAppStoreConnectPages(client, `/appInfos/${encodeURIComponent(appInfos[0].id)}/appInfoLocalizations`);
+}
+export async function fetchAppleAppStoreVersionLocalizations(client, appId) {
+    const appStoreVersions = await requestAllAppStoreConnectPages(client, `/apps/${encodeURIComponent(appId)}/appStoreVersions`);
+    const selectedVersion = selectPreferredAppleAppStoreVersion(appStoreVersions);
+    if (selectedVersion === undefined) {
+        return [];
+    }
+    return requestAllAppStoreConnectPages(client, `/appStoreVersions/${encodeURIComponent(selectedVersion.id)}/appStoreVersionLocalizations`);
+}
+export function mergeAppleLocalizations(appInfoLocalizations, appStoreVersionLocalizations) {
+    const mergedLocalizations = new Map();
+    for (const localization of appInfoLocalizations) {
+        const locale = localization.attributes.locale;
+        if (locale === undefined || locale.trim().length === 0) {
+            continue;
+        }
+        mergedLocalizations.set(locale, {
+            locale,
+            ...mergedLocalizations.get(locale),
+            appInfoLocalization: localization,
+        });
+    }
+    for (const localization of appStoreVersionLocalizations) {
+        const locale = localization.attributes.locale;
+        if (locale === undefined || locale.trim().length === 0) {
+            continue;
+        }
+        mergedLocalizations.set(locale, {
+            locale,
+            ...mergedLocalizations.get(locale),
+            appStoreVersionLocalization: localization,
+        });
+    }
+    return [...mergedLocalizations.values()].sort((left, right) => left.locale.localeCompare(right.locale));
+}
+export function normalizeMergedAppleLocalization(localization) {
+    const appInfoAttributes = localization.appInfoLocalization?.attributes;
+    const versionAttributes = localization.appStoreVersionLocalization?.attributes;
+    return {
+        locale: normalizeLocaleCode(localization.locale),
+        app_name: appInfoAttributes?.name,
+        subtitle: appInfoAttributes?.subtitle,
+        privacy_policy_url: appInfoAttributes?.privacyPolicyUrl,
+        description: versionAttributes?.description,
+        keywords: versionAttributes?.keywords,
+        marketing_url: versionAttributes?.marketingUrl,
+        promotional_text: versionAttributes?.promotionalText,
+        support_url: versionAttributes?.supportUrl,
+        whats_new: versionAttributes?.whatsNew,
+    };
+}
+export function normalizeMergedAppleLocalizations(localizations) {
+    return localizations.map(normalizeMergedAppleLocalization);
+}
+export async function writeAppleMetadataDocument(metadataBaseDir, document) {
+    const normalizedLocale = normalizeLocaleCode(document.locale);
+    return writeMetadataFile(metadataBaseDir, `apple/${normalizedLocale}.yml`, {
+        ...document,
+        locale: normalizedLocale,
+    });
+}
+export async function writeAppleMetadataDocuments(metadataBaseDir, documents) {
+    return Promise.all(documents.map((document) => writeAppleMetadataDocument(metadataBaseDir, document)));
+}

package/dist/platforms/apple/metadata/push.js

@@ -0,0 +1,272 @@
+import { readdir } from "node:fs/promises";
+import { extname, join, resolve } from "node:path";
+import { StoremetaError } from "../../../cli/errors.js";
+import { loadMarkdownMetadataFile, loadYamlMetadataFile, loadYmlMetadataFile, } from "../../../formats/load-metadata.js";
+import { patchAppStoreConnectJson, postAppStoreConnectJson, requestAllAppStoreConnectPages, } from "../client.js";
+import { validateAppleMetadataDocument } from "../../../validation/metadata/apple.js";
+async function listAppleMetadataFiles(metadataBaseDir) {
+    const appleMetadataDirectory = resolve(metadataBaseDir, "apple");
+    try {
+        const entries = await readdir(appleMetadataDirectory, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isFile())
+            .map((entry) => join(appleMetadataDirectory, entry.name))
+            .sort((left, right) => left.localeCompare(right));
+    }
+    catch (cause) {
+        if (typeof cause === "object" &&
+            cause !== null &&
+            "code" in cause &&
+            cause.code === "ENOENT") {
+            return [];
+        }
+        throw new StoremetaError("FILESYSTEM_ERROR", `Failed to read Apple metadata directory at ${appleMetadataDirectory}`, { cause });
+    }
+}
+async function loadAppleMetadataDocument(filePath) {
+    const extension = extname(filePath).toLowerCase();
+    if (extension === ".yml") {
+        return validateAppleMetadataDocument((await loadYmlMetadataFile(filePath)).parsed);
+    }
+    if (extension === ".yaml") {
+        return validateAppleMetadataDocument((await loadYamlMetadataFile(filePath)).parsed);
+    }
+    if (extension === ".md") {
+        return validateAppleMetadataDocument((await loadMarkdownMetadataFile(filePath)).parsed);
+    }
+    return undefined;
+}
+export async function loadAppleMetadataDocuments(metadataBaseDir) {
+    const documents = [];
+    for (const filePath of await listAppleMetadataFiles(metadataBaseDir)) {
+        const document = await loadAppleMetadataDocument(filePath);
+        if (document !== undefined) {
+            documents.push(document);
+        }
+    }
+    return documents.sort((left, right) => left.locale.localeCompare(right.locale));
+}
+export function selectAppleAppInfoResource(appInfos) {
+    const iosAppInfo = appInfos.find((appInfo) => appInfo.attributes?.platform === "IOS");
+    return iosAppInfo ?? appInfos[0];
+}
+export async function resolveAppleAppInfoResource(client, appId) {
+    const appInfos = await requestAllAppStoreConnectPages(client, `/apps/${encodeURIComponent(appId)}/appInfos`);
+    const selectedAppInfo = selectAppleAppInfoResource(appInfos);
+    if (selectedAppInfo === undefined) {
+        throw new StoremetaError("API_ERROR", `App Store Connect returned no app info resource for app ${appId}`);
+    }
+    return selectedAppInfo;
+}
+const EDITABLE_APP_STORE_STATES = new Set([
+    "PREPARE_FOR_SUBMISSION",
+    "READY_FOR_REVIEW",
+    "INVALID_BINARY",
+    "WAITING_FOR_REVIEW",
+    "IN_REVIEW",
+    "ACCEPTED",
+    "WAITING_FOR_EXPORT_COMPLIANCE",
+    "PENDING_DEVELOPER_RELEASE",
+    "REJECTED",
+    "METADATA_REJECTED",
+    "DEVELOPER_REJECTED",
+]);
+function getAppleVersionCreatedTimestamp(version) {
+    const createdDate = version.attributes?.createdDate;
+    if (createdDate === undefined) {
+        return Number.NEGATIVE_INFINITY;
+    }
+    const timestamp = Date.parse(createdDate);
+    return Number.isNaN(timestamp) ? Number.NEGATIVE_INFINITY : timestamp;
+}
+export function selectEditableAppleAppStoreVersion(versions) {
+    const sortedVersions = [...versions].sort((left, right) => {
+        if (left.attributes?.platform === "IOS" && right.attributes?.platform !== "IOS") {
+            return -1;
+        }
+        if (left.attributes?.platform !== "IOS" && right.attributes?.platform === "IOS") {
+            return 1;
+        }
+        const createdDateOrder = getAppleVersionCreatedTimestamp(right) - getAppleVersionCreatedTimestamp(left);
+        if (createdDateOrder !== 0) {
+            return createdDateOrder;
+        }
+        return right.id.localeCompare(left.id);
+    });
+    return sortedVersions.find((version) => {
+        const state = version.attributes?.appStoreState;
+        return state !== undefined && EDITABLE_APP_STORE_STATES.has(state);
+    });
+}
+export async function resolveEditableAppleAppStoreVersionResource(client, appId) {
+    const appStoreVersions = await requestAllAppStoreConnectPages(client, `/apps/${encodeURIComponent(appId)}/appStoreVersions`);
+    const selectedVersion = selectEditableAppleAppStoreVersion(appStoreVersions);
+    if (selectedVersion === undefined) {
+        throw new StoremetaError("API_ERROR", `App Store Connect returned no editable app store version for app ${appId}`);
+    }
+    return selectedVersion;
+}
+function mapAppleMetadataToAppInfoLocalizationPayload(document, localizationId) {
+    return {
+        data: {
+            id: localizationId,
+            type: "appInfoLocalizations",
+            attributes: {
+                locale: document.locale,
+                name: document.app_name,
+                subtitle: document.subtitle,
+                privacyPolicyUrl: document.privacy_policy_url,
+            },
+        },
+    };
+}
+function mapAppleMetadataToAppInfoLocalizationCreatePayload(document, appInfoId) {
+    return {
+        data: {
+            type: "appInfoLocalizations",
+            attributes: {
+                locale: document.locale,
+                name: document.app_name,
+                subtitle: document.subtitle,
+                privacyPolicyUrl: document.privacy_policy_url,
+            },
+            relationships: {
+                appInfo: {
+                    data: {
+                        type: "appInfos",
+                        id: appInfoId,
+                    },
+                },
+            },
+        },
+    };
+}
+async function listAppleAppInfoLocalizations(client, appInfoId) {
+    return requestAllAppStoreConnectPages(client, `/appInfos/${encodeURIComponent(appInfoId)}/appInfoLocalizations`);
+}
+export async function updateExistingAppleAppInfoLocalizations(client, appInfoId, documents) {
+    const localizations = await listAppleAppInfoLocalizations(client, appInfoId);
+    const localizationsByLocale = new Map(localizations
+        .filter((localization) => localization.id !== undefined)
+        .map((localization) => [localization.attributes.locale, localization]));
+    const results = [];
+    for (const document of documents) {
+        const localization = localizationsByLocale.get(document.locale);
+        if (localization?.id === undefined) {
+            continue;
+        }
+        await patchAppStoreConnectJson(client, `/appInfoLocalizations/${encodeURIComponent(localization.id)}`, mapAppleMetadataToAppInfoLocalizationPayload(document, localization.id));
+        results.push({
+            locale: document.locale,
+            localizationId: localization.id,
+        });
+    }
+    return results.sort((left, right) => left.locale.localeCompare(right.locale));
+}
+export async function createMissingAppleAppInfoLocalizations(client, appInfoId, documents) {
+    const localizations = await listAppleAppInfoLocalizations(client, appInfoId);
+    const existingLocales = new Set(localizations
+        .map((localization) => localization.attributes.locale)
+        .filter((locale) => locale !== undefined));
+    const results = [];
+    for (const document of documents) {
+        if (existingLocales.has(document.locale)) {
+            continue;
+        }
+        const response = await postAppStoreConnectJson(client, "/appInfoLocalizations", mapAppleMetadataToAppInfoLocalizationCreatePayload(document, appInfoId));
+        if (response.data.id === undefined) {
+            throw new StoremetaError("API_ERROR", `App Store Connect did not return an app info localization id for locale ${document.locale}`);
+        }
+        results.push({
+            locale: document.locale,
+            localizationId: response.data.id,
+        });
+        existingLocales.add(document.locale);
+    }
+    return results.sort((left, right) => left.locale.localeCompare(right.locale));
+}
+function mapAppleMetadataToAppStoreVersionLocalizationPayload(document, localizationId) {
+    return {
+        data: {
+            id: localizationId,
+            type: "appStoreVersionLocalizations",
+            attributes: {
+                locale: document.locale,
+                description: document.description,
+                keywords: document.keywords,
+                marketingUrl: document.marketing_url,
+                promotionalText: document.promotional_text,
+                supportUrl: document.support_url,
+                whatsNew: document.whats_new,
+            },
+        },
+    };
+}
+function mapAppleMetadataToAppStoreVersionLocalizationCreatePayload(document, appStoreVersionId) {
+    return {
+        data: {
+            type: "appStoreVersionLocalizations",
+            attributes: {
+                locale: document.locale,
+                description: document.description,
+                keywords: document.keywords,
+                marketingUrl: document.marketing_url,
+                promotionalText: document.promotional_text,
+                supportUrl: document.support_url,
+                whatsNew: document.whats_new,
+            },
+            relationships: {
+                appStoreVersion: {
+                    data: {
+                        type: "appStoreVersions",
+                        id: appStoreVersionId,
+                    },
+                },
+            },
+        },
+    };
+}
+async function listAppleAppStoreVersionLocalizations(client, appStoreVersionId) {
+    return requestAllAppStoreConnectPages(client, `/appStoreVersions/${encodeURIComponent(appStoreVersionId)}/appStoreVersionLocalizations`);
+}
+export async function updateExistingAppleAppStoreVersionLocalizations(client, appStoreVersionId, documents) {
+    const localizations = await listAppleAppStoreVersionLocalizations(client, appStoreVersionId);
+    const localizationsByLocale = new Map(localizations
+        .filter((localization) => localization.id !== undefined)
+        .map((localization) => [localization.attributes.locale, localization]));
+    const results = [];
+    for (const document of documents) {
+        const localization = localizationsByLocale.get(document.locale);
+        if (localization?.id === undefined) {
+            continue;
+        }
+        await patchAppStoreConnectJson(client, `/appStoreVersionLocalizations/${encodeURIComponent(localization.id)}`, mapAppleMetadataToAppStoreVersionLocalizationPayload(document, localization.id));
+        results.push({
+            locale: document.locale,
+            localizationId: localization.id,
+        });
+    }
+    return results.sort((left, right) => left.locale.localeCompare(right.locale));
+}
+export async function createMissingAppleAppStoreVersionLocalizations(client, appStoreVersionId, documents) {
+    const localizations = await listAppleAppStoreVersionLocalizations(client, appStoreVersionId);
+    const existingLocales = new Set(localizations
+        .map((localization) => localization.attributes.locale)
+        .filter((locale) => locale !== undefined));
+    const results = [];
+    for (const document of documents) {
+        if (existingLocales.has(document.locale)) {
+            continue;
+        }
+        const response = await postAppStoreConnectJson(client, "/appStoreVersionLocalizations", mapAppleMetadataToAppStoreVersionLocalizationCreatePayload(document, appStoreVersionId));
+        if (response.data.id === undefined) {
+            throw new StoremetaError("API_ERROR", `App Store Connect did not return an app store version localization id for locale ${document.locale}`);
+        }
+        results.push({
+            locale: document.locale,
+            localizationId: response.data.id,
+        });
+        existingLocales.add(document.locale);
+    }
+    return results.sort((left, right) => left.locale.localeCompare(right.locale));
+}

package/dist/platforms/apple/metadata/types.js

@@ -0,0 +1 @@
+export {};

package/dist/platforms/apple/screenshots/pull.js

@@ -0,0 +1,160 @@
+import { normalizeLocaleCode } from "../../../locales/normalize.js";
+import { writeFile } from "node:fs/promises";
+import { extname } from "node:path";
+import { StoremetaError } from "../../../cli/errors.js";
+import { ensureParentDirectory } from "../../../writers/ensure-directory.js";
+import { orderScreenshotsForWrite } from "../../../writers/order-screenshots.js";
+import { resolveScreenshotFilePath } from "../../../writers/resolve-screenshot-path.js";
+import { requestAllAppStoreConnectPages } from "../client.js";
+import { fetchAppleAppStoreVersionLocalizations, } from "../metadata/pull.js";
+export async function fetchAppleScreenshotLocalizations(client, appId) {
+    return fetchAppleAppStoreVersionLocalizations(client, appId);
+}
+export function filterAppleScreenshotLocalizationsByLocale(localizations, locale) {
+    if (locale === undefined) {
+        return localizations;
+    }
+    const normalizedLocale = normalizeLocaleCode(locale);
+    return localizations.filter((localization) => normalizeLocaleCode(localization.attributes.locale ?? "") ===
+        normalizedLocale);
+}
+export async function fetchAppleScreenshotSetsForLocalizations(client, localizations) {
+    const results = [];
+    for (const localization of localizations) {
+        if (localization.id === undefined) {
+            continue;
+        }
+        const screenshotSets = await requestAllAppStoreConnectPages(client, `/appStoreVersionLocalizations/${encodeURIComponent(localization.id)}/appScreenshotSets`);
+        results.push({
+            localizationId: localization.id,
+            locale: localization.attributes.locale,
+            screenshotSets,
+        });
+    }
+    return results.sort((left, right) => (left.locale ?? left.localizationId).localeCompare(right.locale ?? right.localizationId));
+}
+export async function fetchAppleScreenshotsForSets(client, screenshotSetsByLocalization) {
+    const results = [];
+    for (const localization of screenshotSetsByLocalization) {
+        for (const screenshotSet of localization.screenshotSets) {
+            const screenshots = await requestAllAppStoreConnectPages(client, `/appScreenshotSets/${encodeURIComponent(screenshotSet.id)}/appScreenshots`);
+            results.push({
+                localizationId: localization.localizationId,
+                locale: localization.locale,
+                screenshotSet,
+                screenshots,
+            });
+        }
+    }
+    return results.sort((left, right) => {
+        const localeOrder = (left.locale ?? left.localizationId).localeCompare(right.locale ?? right.localizationId);
+        if (localeOrder !== 0) {
+            return localeOrder;
+        }
+        return left.screenshotSet.id.localeCompare(right.screenshotSet.id);
+    });
+}
+function resolveAppleScreenshotExtension(screenshot, contentType) {
+    if (contentType?.includes("png")) {
+        return ".png";
+    }
+    if (contentType?.includes("jpeg") || contentType?.includes("jpg")) {
+        return ".jpg";
+    }
+    const fileNameExtension = extname(screenshot.attributes?.fileName ?? "").toLowerCase();
+    if (fileNameExtension.length > 0) {
+        return fileNameExtension;
+    }
+    return ".png";
+}
+function replaceAppleImageAssetTemplateValue(templateUrl, token, value) {
+    if (!templateUrl.includes(token)) {
+        return templateUrl;
+    }
+    if (value === undefined) {
+        throw new StoremetaError("API_ERROR", `Apple screenshot image asset is missing ${token} data for template expansion`);
+    }
+    return templateUrl.replaceAll(token, String(value));
+}
+function resolveAppleScreenshotDownloadUrl(screenshot) {
+    const imageAsset = screenshot.attributes?.imageAsset;
+    if (imageAsset?.url !== undefined && imageAsset.url.trim().length > 0) {
+        return imageAsset.url;
+    }
+    if (imageAsset?.templateUrl !== undefined &&
+        imageAsset.templateUrl.trim().length > 0) {
+        const extension = resolveAppleScreenshotExtension(screenshot).replace(/^\./u, "");
+        let downloadUrl = imageAsset.templateUrl;
+        downloadUrl = replaceAppleImageAssetTemplateValue(downloadUrl, "{w}", imageAsset.width);
+        downloadUrl = replaceAppleImageAssetTemplateValue(downloadUrl, "{h}", imageAsset.height);
+        downloadUrl = replaceAppleImageAssetTemplateValue(downloadUrl, "{f}", extension);
+        return downloadUrl;
+    }
+    throw new StoremetaError("API_ERROR", `Apple screenshot ${screenshot.id} does not include a downloadable image asset`);
+}
+export async function downloadAppleScreenshot(screenshot) {
+    const response = await fetch(resolveAppleScreenshotDownloadUrl(screenshot));
+    if (!response.ok) {
+        throw new StoremetaError("API_ERROR", `Failed to download Apple screenshot ${screenshot.id} with ${response.status} ${response.statusText}`);
+    }
+    return {
+        buffer: new Uint8Array(await response.arrayBuffer()),
+        extension: resolveAppleScreenshotExtension(screenshot, response.headers.get("content-type")),
+    };
+}
+function resolveAppleScreenshotFileName(screenshot, extension) {
+    const sourceFileName = screenshot.attributes?.fileName;
+    if (sourceFileName !== undefined && sourceFileName.trim().length > 0) {
+        return sourceFileName;
+    }
+    return `${screenshot.id}${extension}`;
+}
+export async function downloadAppleScreenshotSet(screenshotsBaseDir, screenshotSet) {
+    const locale = normalizeLocaleCode(screenshotSet.locale ?? "en-US");
+    const assetType = screenshotSet.screenshotSet.attributes?.screenshotDisplayType ??
+        screenshotSet.screenshotSet.id;
+    const downloadedScreenshots = [];
+    for (const [index, screenshot] of screenshotSet.screenshots.entries()) {
+        const position = index + 1;
+        const downloadedScreenshot = await downloadAppleScreenshot(screenshot);
+        const fileName = resolveAppleScreenshotFileName(screenshot, downloadedScreenshot.extension);
+        downloadedScreenshots.push({
+            descriptor: {
+                platform: "apple",
+                locale,
+                assetType,
+                filePath: "",
+                fileName,
+                position,
+            },
+            buffer: downloadedScreenshot.buffer,
+        });
+    }
+    const orderedFiles = orderScreenshotsForWrite(downloadedScreenshots.map((screenshot) => screenshot.descriptor));
+    const files = [];
+    for (const [index, orderedFile] of orderedFiles.entries()) {
+        const filePath = resolveScreenshotFilePath(screenshotsBaseDir, {
+            platform: "apple",
+            locale,
+            assetType,
+            fileName: orderedFile.fileName,
+        });
+        await ensureParentDirectory(filePath);
+        try {
+            await writeFile(filePath, downloadedScreenshots[index].buffer);
+        }
+        catch (cause) {
+            throw new StoremetaError("FILESYSTEM_ERROR", `Failed to write Apple screenshot ${locale}/${assetType}/${orderedFile.fileName}`, { cause });
+        }
+        files.push({
+            ...orderedFile,
+            filePath,
+        });
+    }
+    return {
+        platform: "apple",
+        locale,
+        assetType,
+        files,
+    };
+}