storemeta 0.1.0

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

@@ -0,0 +1,418 @@
+import { createHash } from "node:crypto";
+import { readFile, readdir, stat } from "node:fs/promises";
+import { extname, join, resolve } from "node:path";
+import { StoremetaError } from "../../../cli/errors.js";
+import { normalizeLocaleCode } from "../../../locales/normalize.js";
+import { patchAppStoreConnectJson, postAppStoreConnectJson, requestAllAppStoreConnectPages, } from "../client.js";
+import { resolveEditableAppleAppStoreVersionResource } from "../metadata/push.js";
+import { fetchAppleScreenshotsForSets, fetchAppleScreenshotSetsForLocalizations, } from "./pull.js";
+const SUPPORTED_SCREENSHOT_EXTENSIONS = new Set([".png", ".jpg", ".jpeg"]);
+async function listDirectoryEntries(directoryPath) {
+    try {
+        return await readdir(directoryPath, { withFileTypes: true });
+    }
+    catch (cause) {
+        if (typeof cause === "object" &&
+            cause !== null &&
+            "code" in cause &&
+            cause.code === "ENOENT") {
+            return [];
+        }
+        throw new StoremetaError("FILESYSTEM_ERROR", `Failed to read Apple screenshot directory at ${directoryPath}`, { cause });
+    }
+}
+function sortScreenshotFileNames(fileNames) {
+    return [...fileNames].sort((left, right) => left.localeCompare(right, undefined, {
+        numeric: true,
+    }));
+}
+function validateAppleScreenshotFileNames(assetTypeDirectory, fileNames) {
+    for (const [index, fileName] of sortScreenshotFileNames(fileNames).entries()) {
+        const extension = extname(fileName).toLowerCase();
+        if (!SUPPORTED_SCREENSHOT_EXTENSIONS.has(extension)) {
+            throw new StoremetaError("VALIDATION_ERROR", `${join(assetTypeDirectory, fileName)}: unsupported screenshot file extension`);
+        }
+        const numericName = fileName.slice(0, Math.max(0, fileName.length - extension.length));
+        if (!/^\d+$/u.test(numericName)) {
+            throw new StoremetaError("VALIDATION_ERROR", `${join(assetTypeDirectory, fileName)}: expected a numeric filename`);
+        }
+        if (Number(numericName) !== index + 1) {
+            throw new StoremetaError("VALIDATION_ERROR", `${join(assetTypeDirectory, fileName)}: expected screenshot order ${index + 1}`);
+        }
+    }
+}
+function createAppleScreenshotDescriptors(screenshotsBaseDir, localeDirectoryName, locale, assetType, fileNames) {
+    return sortScreenshotFileNames(fileNames).map((fileName, index) => ({
+        platform: "apple",
+        locale,
+        assetType,
+        filePath: resolve(screenshotsBaseDir, "apple", localeDirectoryName, assetType, fileName),
+        fileName,
+        position: index + 1,
+    }));
+}
+export async function loadAppleScreenshotSets(screenshotsBaseDir) {
+    const appleBaseDir = resolve(screenshotsBaseDir, "apple");
+    const localeEntries = await listDirectoryEntries(appleBaseDir);
+    const screenshotSets = [];
+    for (const localeEntry of localeEntries) {
+        if (!localeEntry.isDirectory()) {
+            throw new StoremetaError("VALIDATION_ERROR", `${join(appleBaseDir, localeEntry.name)}: expected a locale directory`);
+        }
+        const locale = normalizeLocaleCode(localeEntry.name);
+        const localeDirectory = join(appleBaseDir, localeEntry.name);
+        const assetTypeEntries = await listDirectoryEntries(localeDirectory);
+        for (const assetTypeEntry of assetTypeEntries) {
+            if (!assetTypeEntry.isDirectory()) {
+                throw new StoremetaError("VALIDATION_ERROR", `${join(localeDirectory, assetTypeEntry.name)}: expected a display type directory`);
+            }
+            const assetTypeDirectory = join(localeDirectory, assetTypeEntry.name);
+            const fileEntries = await listDirectoryEntries(assetTypeDirectory);
+            const fileNames = fileEntries
+                .filter((entry) => entry.isFile())
+                .map((entry) => entry.name);
+            validateAppleScreenshotFileNames(assetTypeDirectory, fileNames);
+            screenshotSets.push({
+                platform: "apple",
+                locale,
+                assetType: assetTypeEntry.name,
+                files: createAppleScreenshotDescriptors(screenshotsBaseDir, localeEntry.name, locale, assetTypeEntry.name, fileNames),
+            });
+        }
+    }
+    return screenshotSets.sort((left, right) => {
+        const localeOrder = left.locale.localeCompare(right.locale);
+        if (localeOrder !== 0) {
+            return localeOrder;
+        }
+        return left.assetType.localeCompare(right.assetType);
+    });
+}
+function mapAppleScreenshotLocaleToCreatePayload(locale, appStoreVersionId) {
+    return {
+        data: {
+            type: "appStoreVersionLocalizations",
+            attributes: {
+                locale,
+            },
+            relationships: {
+                appStoreVersion: {
+                    data: {
+                        type: "appStoreVersions",
+                        id: appStoreVersionId,
+                    },
+                },
+            },
+        },
+    };
+}
+async function listAppleAppStoreVersionLocalizations(client, appStoreVersionId) {
+    return requestAllAppStoreConnectPages(client, `/appStoreVersions/${encodeURIComponent(appStoreVersionId)}/appStoreVersionLocalizations`);
+}
+export async function resolveOrCreateAppleScreenshotLocalizations(client, appId, screenshotSets) {
+    const appStoreVersion = await resolveEditableAppleAppStoreVersionResource(client, appId);
+    const existingLocalizations = await listAppleAppStoreVersionLocalizations(client, appStoreVersion.id);
+    const localizationsByLocale = new Map(existingLocalizations
+        .filter((localization) => localization.attributes.locale !== undefined)
+        .map((localization) => [localization.attributes.locale, localization]));
+    const requiredLocales = [...new Set(screenshotSets.map((set) => set.locale))].sort((left, right) => left.localeCompare(right));
+    for (const locale of requiredLocales) {
+        if (localizationsByLocale.has(locale)) {
+            continue;
+        }
+        const response = await postAppStoreConnectJson(client, "/appStoreVersionLocalizations", mapAppleScreenshotLocaleToCreatePayload(locale, appStoreVersion.id));
+        if (response.data.id === undefined) {
+            throw new StoremetaError("API_ERROR", `App Store Connect did not return an app store version localization id for locale ${locale}`);
+        }
+        localizationsByLocale.set(locale, response.data);
+    }
+    return requiredLocales.map((locale) => {
+        const localization = localizationsByLocale.get(locale);
+        if (localization === undefined) {
+            throw new StoremetaError("API_ERROR", `App Store Connect did not return an app store version localization for locale ${locale}`);
+        }
+        return localization;
+    });
+}
+function mapAppleScreenshotSetToCreatePayload(localizationId, screenshotDisplayType) {
+    return {
+        data: {
+            type: "appScreenshotSets",
+            attributes: {
+                screenshotDisplayType,
+            },
+            relationships: {
+                appStoreVersionLocalization: {
+                    data: {
+                        type: "appStoreVersionLocalizations",
+                        id: localizationId,
+                    },
+                },
+            },
+        },
+    };
+}
+export async function resolveOrCreateAppleScreenshotUploadTargets(client, localizations, screenshotSets) {
+    const localizationsByLocale = new Map(localizations
+        .filter((localization) => localization.id !== undefined &&
+        localization.attributes.locale !== undefined)
+        .map((localization) => [localization.attributes.locale, localization]));
+    const existingScreenshotSets = await fetchAppleScreenshotSetsForLocalizations(client, localizations);
+    const screenshotSetsByTargetKey = new Map();
+    for (const localization of existingScreenshotSets) {
+        for (const screenshotSet of localization.screenshotSets) {
+            const displayType = screenshotSet.attributes?.screenshotDisplayType;
+            if (displayType === undefined) {
+                continue;
+            }
+            screenshotSetsByTargetKey.set(`${localization.localizationId}:${displayType}`, screenshotSet);
+        }
+    }
+    const uploadTargets = [];
+    for (const screenshotSet of screenshotSets) {
+        const localization = localizationsByLocale.get(screenshotSet.locale);
+        if (localization === undefined) {
+            throw new StoremetaError("API_ERROR", `App Store Connect did not return an app store version localization for locale ${screenshotSet.locale}`);
+        }
+        const targetKey = `${localization.id}:${screenshotSet.assetType}`;
+        let targetScreenshotSet = screenshotSetsByTargetKey.get(targetKey);
+        if (targetScreenshotSet === undefined) {
+            const response = await postAppStoreConnectJson(client, "/appScreenshotSets", mapAppleScreenshotSetToCreatePayload(localization.id, screenshotSet.assetType));
+            if (response.data.id === undefined) {
+                throw new StoremetaError("API_ERROR", `App Store Connect did not return an app screenshot set id for locale ${screenshotSet.locale} and display type ${screenshotSet.assetType}`);
+            }
+            targetScreenshotSet = response.data;
+            screenshotSetsByTargetKey.set(targetKey, targetScreenshotSet);
+        }
+        uploadTargets.push({
+            ...screenshotSet,
+            localizationId: localization.id,
+            screenshotSetId: targetScreenshotSet.id,
+        });
+    }
+    return uploadTargets.sort((left, right) => {
+        const localeOrder = left.locale.localeCompare(right.locale);
+        if (localeOrder !== 0) {
+            return localeOrder;
+        }
+        return left.assetType.localeCompare(right.assetType);
+    });
+}
+function mapUploadTargetsToAppleLocalizationScreenshotSets(uploadTargets) {
+    const targetsByLocalization = new Map();
+    for (const uploadTarget of uploadTargets) {
+        const existingLocalization = targetsByLocalization.get(uploadTarget.localizationId);
+        if (existingLocalization !== undefined) {
+            existingLocalization.screenshotSets.push({
+                id: uploadTarget.screenshotSetId,
+                type: "appScreenshotSets",
+                attributes: {
+                    screenshotDisplayType: uploadTarget.assetType,
+                },
+            });
+            continue;
+        }
+        targetsByLocalization.set(uploadTarget.localizationId, {
+            localizationId: uploadTarget.localizationId,
+            locale: uploadTarget.locale,
+            screenshotSets: [
+                {
+                    id: uploadTarget.screenshotSetId,
+                    type: "appScreenshotSets",
+                    attributes: {
+                        screenshotDisplayType: uploadTarget.assetType,
+                    },
+                },
+            ],
+        });
+    }
+    return [...targetsByLocalization.values()].sort((left, right) => (left.locale ?? left.localizationId).localeCompare(right.locale ?? right.localizationId));
+}
+export async function clearAppleScreenshotUploadTargets(client, uploadTargets, options) {
+    if (options?.clearExisting !== true) {
+        return [];
+    }
+    const screenshotsBySet = await fetchAppleScreenshotsForSets(client, mapUploadTargetsToAppleLocalizationScreenshotSets(uploadTargets));
+    const deletedResults = [];
+    for (const screenshotSet of screenshotsBySet) {
+        const deletedScreenshotIds = [];
+        for (const screenshot of screenshotSet.screenshots) {
+            await client.request(`/appScreenshots/${encodeURIComponent(screenshot.id)}`, {
+                method: "DELETE",
+            });
+            deletedScreenshotIds.push(screenshot.id);
+        }
+        deletedResults.push({
+            locale: screenshotSet.locale ?? screenshotSet.localizationId,
+            assetType: screenshotSet.screenshotSet.attributes?.screenshotDisplayType ??
+                screenshotSet.screenshotSet.id,
+            screenshotSetId: screenshotSet.screenshotSet.id,
+            deletedScreenshotIds,
+        });
+    }
+    return deletedResults.sort((left, right) => {
+        const localeOrder = left.locale.localeCompare(right.locale);
+        if (localeOrder !== 0) {
+            return localeOrder;
+        }
+        return left.assetType.localeCompare(right.assetType);
+    });
+}
+function mapAppleScreenshotReservationPayload(screenshotSetId, fileName, fileSize) {
+    return {
+        data: {
+            type: "appScreenshots",
+            attributes: {
+                fileName,
+                fileSize,
+            },
+            relationships: {
+                appScreenshotSet: {
+                    data: {
+                        type: "appScreenshotSets",
+                        id: screenshotSetId,
+                    },
+                },
+            },
+        },
+    };
+}
+export async function reserveAppleScreenshotUploads(client, uploadTargets) {
+    const reservations = [];
+    for (const uploadTarget of uploadTargets) {
+        for (const file of uploadTarget.files) {
+            const fileStats = await stat(file.filePath);
+            const response = await postAppStoreConnectJson(client, "/appScreenshots", mapAppleScreenshotReservationPayload(uploadTarget.screenshotSetId, file.fileName, fileStats.size));
+            const screenshotId = response.data.id;
+            const uploadOperations = response.data.attributes?.uploadOperations;
+            if (screenshotId === undefined) {
+                throw new StoremetaError("API_ERROR", `App Store Connect did not return an app screenshot id for ${uploadTarget.locale}/${uploadTarget.assetType}/${file.fileName}`);
+            }
+            if (uploadOperations === undefined || uploadOperations.length === 0) {
+                throw new StoremetaError("API_ERROR", `App Store Connect did not return upload operations for ${uploadTarget.locale}/${uploadTarget.assetType}/${file.fileName}`);
+            }
+            reservations.push({
+                locale: uploadTarget.locale,
+                assetType: uploadTarget.assetType,
+                screenshotSetId: uploadTarget.screenshotSetId,
+                screenshotId,
+                file,
+                uploadOperations,
+            });
+        }
+    }
+    return reservations.sort((left, right) => {
+        const localeOrder = left.locale.localeCompare(right.locale);
+        if (localeOrder !== 0) {
+            return localeOrder;
+        }
+        const assetTypeOrder = left.assetType.localeCompare(right.assetType);
+        if (assetTypeOrder !== 0) {
+            return assetTypeOrder;
+        }
+        return left.file.position - right.file.position;
+    });
+}
+function resolveAppleUploadOperationHeaders(uploadOperation) {
+    const headers = Object.fromEntries((uploadOperation.requestHeaders ?? [])
+        .filter((header) => header.name !== undefined && header.value !== undefined)
+        .map((header) => [header.name, header.value]));
+    if (Object.keys(headers).length === 0) {
+        throw new StoremetaError("API_ERROR", "Apple upload operation did not return request headers");
+    }
+    return headers;
+}
+function sliceAppleUploadChunk(fileBuffer, uploadOperation) {
+    if (uploadOperation.offset === undefined || uploadOperation.length === undefined) {
+        throw new StoremetaError("API_ERROR", "Apple upload operation did not return offset and length information");
+    }
+    return fileBuffer.subarray(uploadOperation.offset, uploadOperation.offset + uploadOperation.length);
+}
+function convertAppleUploadChunkToArrayBuffer(chunk) {
+    return chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength);
+}
+export async function uploadReservedAppleScreenshot(reservation) {
+    const fileBuffer = await readFile(reservation.file.filePath);
+    for (const uploadOperation of reservation.uploadOperations) {
+        if (uploadOperation.method === undefined ||
+            uploadOperation.url === undefined ||
+            uploadOperation.url.trim().length === 0) {
+            throw new StoremetaError("API_ERROR", `Apple upload operation is missing method or URL for ${reservation.locale}/${reservation.assetType}/${reservation.file.fileName}`);
+        }
+        const response = await fetch(uploadOperation.url, {
+            method: uploadOperation.method,
+            headers: resolveAppleUploadOperationHeaders(uploadOperation),
+            body: convertAppleUploadChunkToArrayBuffer(sliceAppleUploadChunk(fileBuffer, uploadOperation)),
+        });
+        if (!response.ok) {
+            throw new StoremetaError("API_ERROR", `Apple screenshot upload failed for ${reservation.locale}/${reservation.assetType}/${reservation.file.fileName} with ${response.status} ${response.statusText}`);
+        }
+    }
+    return {
+        locale: reservation.locale,
+        assetType: reservation.assetType,
+        screenshotId: reservation.screenshotId,
+        filePath: reservation.file.filePath,
+    };
+}
+export async function uploadReservedAppleScreenshots(reservations) {
+    const uploadResults = [];
+    for (const reservation of reservations) {
+        uploadResults.push(await uploadReservedAppleScreenshot(reservation));
+    }
+    return uploadResults.sort((left, right) => {
+        const localeOrder = left.locale.localeCompare(right.locale);
+        if (localeOrder !== 0) {
+            return localeOrder;
+        }
+        const assetTypeOrder = left.assetType.localeCompare(right.assetType);
+        if (assetTypeOrder !== 0) {
+            return assetTypeOrder;
+        }
+        return left.filePath.localeCompare(right.filePath);
+    });
+}
+function createAppleScreenshotChecksum(fileContents) {
+    return createHash("md5").update(fileContents).digest("hex");
+}
+function mapAppleScreenshotCommitPayload(screenshotId, sourceFileChecksum) {
+    return {
+        data: {
+            id: screenshotId,
+            type: "appScreenshots",
+            attributes: {
+                uploaded: true,
+                sourceFileChecksum,
+            },
+        },
+    };
+}
+export async function commitAppleScreenshotUpload(client, reservation) {
+    const fileContents = await readFile(reservation.file.filePath);
+    const sourceFileChecksum = createAppleScreenshotChecksum(fileContents);
+    await patchAppStoreConnectJson(client, `/appScreenshots/${encodeURIComponent(reservation.screenshotId)}`, mapAppleScreenshotCommitPayload(reservation.screenshotId, sourceFileChecksum));
+    return {
+        locale: reservation.locale,
+        assetType: reservation.assetType,
+        screenshotId: reservation.screenshotId,
+        filePath: reservation.file.filePath,
+        sourceFileChecksum,
+    };
+}
+export async function commitAppleScreenshotUploads(client, reservations) {
+    const commitResults = [];
+    for (const reservation of reservations) {
+        commitResults.push(await commitAppleScreenshotUpload(client, reservation));
+    }
+    return commitResults.sort((left, right) => {
+        const localeOrder = left.locale.localeCompare(right.locale);
+        if (localeOrder !== 0) {
+            return localeOrder;
+        }
+        const assetTypeOrder = left.assetType.localeCompare(right.assetType);
+        if (assetTypeOrder !== 0) {
+            return assetTypeOrder;
+        }
+        return left.filePath.localeCompare(right.filePath);
+    });
+}

package/dist/platforms/google/client.js

@@ -0,0 +1,42 @@
+import { StoremetaError } from "../../cli/errors.js";
+import { getGoogleAccessToken } from "../../auth/google/service-account-auth.js";
+const GOOGLE_PLAY_API_BASE_URL = "https://androidpublisher.googleapis.com/androidpublisher/v3";
+export class GooglePlayClient {
+    credentials;
+    env;
+    constructor(credentials, env = process.env) {
+        this.credentials = credentials;
+        this.env = env;
+    }
+    async request(path, options = {}) {
+        const accessToken = await getGoogleAccessToken(this.credentials, this.env);
+        const requestUrl = path.startsWith("https://") || path.startsWith("http://")
+            ? path
+            : `${GOOGLE_PLAY_API_BASE_URL}${path}`;
+        const response = await fetch(requestUrl, {
+            method: options.method ?? "GET",
+            headers: {
+                Authorization: `Bearer ${accessToken}`,
+                ...options.headers,
+            },
+            body: options.body,
+        });
+        if (!response.ok) {
+            throw new StoremetaError("API_ERROR", `Google Play API request failed with ${response.status} ${response.statusText}`);
+        }
+        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 createGooglePlayClient(credentials, env = process.env) {
+    return new GooglePlayClient(credentials, env);
+}

package/dist/platforms/google/edits.js

@@ -0,0 +1,38 @@
+import { StoremetaError } from "../../cli/errors.js";
+export async function createGoogleEdit(client, packageName) {
+    return client.requestJson(`/applications/${encodeURIComponent(packageName)}/edits`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({}),
+    });
+}
+export async function commitGoogleEdit(client, packageName, editId, options) {
+    const query = new URLSearchParams();
+    if (options?.changesNotSentForReview !== undefined) {
+        query.set("changesNotSentForReview", String(options.changesNotSentForReview));
+    }
+    const querySuffix = query.size === 0 ? "" : `?${query.toString()}`;
+    return client.requestJson(`/applications/${encodeURIComponent(packageName)}/edits/${encodeURIComponent(editId)}:commit${querySuffix}`, {
+        method: "POST",
+    });
+}
+export async function withGoogleEditSession(client, packageName, run, options) {
+    const edit = await createGoogleEdit(client, packageName);
+    try {
+        const result = await run(edit);
+        if (options?.autoCommit !== false) {
+            await commitGoogleEdit(client, packageName, edit.id, {
+                changesNotSentForReview: options?.changesNotSentForReview,
+            });
+        }
+        return {
+            edit,
+            result,
+        };
+    }
+    catch (cause) {
+        throw new StoremetaError("API_ERROR", `Google Play edit session ${edit.id} failed before commit`, { cause });
+    }
+}

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

@@ -0,0 +1,23 @@
+import { normalizeLocaleCode } from "../../../locales/normalize.js";
+import { writeMetadataFile } from "../../../writers/write-metadata.js";
+export async function fetchGoogleListingForLocale(client, packageName, editId, locale) {
+    return client.requestJson(`/applications/${encodeURIComponent(packageName)}/edits/${encodeURIComponent(editId)}/listings/${encodeURIComponent(locale)}`);
+}
+export async function fetchGoogleListingsForLocales(client, packageName, editId, locales) {
+    return Promise.all(locales.map((locale) => fetchGoogleListingForLocale(client, packageName, editId, locale)));
+}
+export function normalizeGoogleListing(listing) {
+    return {
+        locale: normalizeLocaleCode(listing.language),
+        title: listing.title,
+        short_description: listing.shortDescription,
+        full_description: listing.fullDescription,
+        video: listing.video,
+    };
+}
+export async function writeGoogleListingDocument(metadataBaseDir, document) {
+    return writeMetadataFile(metadataBaseDir, `google/${normalizeLocaleCode(document.locale)}.yml`, document);
+}
+export async function writeGoogleListingDocuments(metadataBaseDir, documents) {
+    return Promise.all(documents.map((document) => writeGoogleListingDocument(metadataBaseDir, document)));
+}

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

@@ -0,0 +1,73 @@
+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 { validateGoogleMetadataDocument, validateGoogleMetadataLengthConstraints, } from "../../../validation/metadata/google.js";
+async function loadGoogleMetadataFile(filePath) {
+    const extension = extname(filePath).toLowerCase();
+    if (extension === ".yml") {
+        return validateGoogleMetadataDocument((await loadYmlMetadataFile(filePath)).parsed);
+    }
+    if (extension === ".yaml") {
+        return validateGoogleMetadataDocument((await loadYamlMetadataFile(filePath)).parsed);
+    }
+    if (extension === ".md") {
+        return validateGoogleMetadataDocument((await loadMarkdownMetadataFile(filePath)).parsed);
+    }
+    return undefined;
+}
+export async function loadGoogleMetadataDocuments(metadataBaseDir) {
+    const googleMetadataDir = resolve(metadataBaseDir, "google");
+    let entries;
+    try {
+        entries = await readdir(googleMetadataDir, { withFileTypes: true });
+    }
+    catch (cause) {
+        throw new StoremetaError("FILESYSTEM_ERROR", `Failed to read local Google metadata directory at ${googleMetadataDir}`, { cause });
+    }
+    const documents = [];
+    for (const entry of entries.sort((left, right) => left.name.localeCompare(right.name))) {
+        if (!entry.isFile()) {
+            continue;
+        }
+        const document = await loadGoogleMetadataFile(join(googleMetadataDir, entry.name));
+        if (document === undefined) {
+            continue;
+        }
+        validateGoogleMetadataLengthConstraints(document);
+        documents.push(document);
+    }
+    return documents;
+}
+export function mapGoogleMetadataDocument(document) {
+    return {
+        language: document.locale,
+        body: {
+            title: document.title,
+            shortDescription: document.short_description,
+            fullDescription: document.full_description,
+            video: document.video,
+        },
+    };
+}
+export function mapGoogleMetadataDocuments(documents) {
+    return documents.map(mapGoogleMetadataDocument);
+}
+export async function uploadGoogleListing(client, packageName, editId, update) {
+    await client.request(`/applications/${encodeURIComponent(packageName)}/edits/${encodeURIComponent(editId)}/listings/${encodeURIComponent(update.language)}`, {
+        method: "PUT",
+        headers: {
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+            language: update.language,
+            ...update.body,
+        }),
+    });
+}
+export async function uploadGoogleListings(client, packageName, editId, updates, options) {
+    for (const update of updates) {
+        await uploadGoogleListing(client, packageName, editId, update);
+        options?.onUploaded?.(update);
+    }
+}

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

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