@owask/tapace-templates 0.0.0-stage → 0.1.0

package/dist/compiler/preview-model.js

@@ -0,0 +1,402 @@
+import { z } from 'zod';
+import { imageAssetId, posterLogoAssetId, resolveCardItem, } from '../contract/index.js';
+import { renderApple, renderGoogle, } from './passmint-compiler.js';
+const NativeField = z.object({
+    key: z.string(),
+    label: z.string().default(''),
+    value: z.union([z.string(), z.number()]).transform(String),
+    dateStyle: z.string().optional(),
+    timeStyle: z.string().optional(),
+    textAlignment: z
+        .enum([
+        'PKTextAlignmentLeft',
+        'PKTextAlignmentCenter',
+        'PKTextAlignmentRight',
+        'PKTextAlignmentNatural',
+    ])
+        .optional(),
+});
+const NativeStyleFields = z.object({
+    headerFields: z.array(NativeField).default([]),
+    primaryFields: z.array(NativeField).default([]),
+    secondaryFields: z.array(NativeField).default([]),
+    auxiliaryFields: z.array(NativeField).default([]),
+    backFields: z.array(NativeField).default([]),
+});
+const NativePosterFields = z.object({
+    headerFields: z.array(NativeField).default([]),
+    primaryFields: z.array(NativeField).default([]),
+    footerFields: z.array(NativeField).default([]),
+    additionalInfoFields: z.array(NativeField).default([]),
+    backFields: z.array(NativeField).default([]),
+});
+const NativeApple = z.object({
+    organizationName: z.string(),
+    description: z.string(),
+    logoText: z.string().optional(),
+    backgroundColor: z.string(),
+    foregroundColor: z.string(),
+    labelColor: z.string().optional(),
+    generic: NativeStyleFields.optional(),
+    eventTicket: NativeStyleFields.optional(),
+    storeCard: NativeStyleFields.optional(),
+    posterGeneric: NativePosterFields.optional(),
+    featuredActions: z
+        .array(z.object({ identifier: z.string(), type: z.string(), url: z.string() }))
+        .default([]),
+    barcodes: z
+        .array(z.object({
+        format: z.string(),
+        message: z.string(),
+        altText: z.string().optional(),
+    }))
+        .default([]),
+});
+const LocalizedText = z.object({
+    defaultValue: z.object({ value: z.string() }),
+});
+const NativeImage = z.object({ sourceUri: z.object({ uri: z.string() }) });
+const NativeTextModules = z
+    .array(z.object({
+    id: z.string(),
+    header: z.string().default(''),
+    body: z.string(),
+}))
+    .default([]);
+const NativeBarcode = z
+    .object({
+    type: z.string(),
+    value: z.string(),
+    alternateText: z.string().optional(),
+})
+    .optional();
+const NativeEventClass = z.object({
+    issuerName: z.string(),
+    eventName: LocalizedText,
+    venue: z.object({ name: LocalizedText, address: LocalizedText }).optional(),
+    dateTime: z
+        .object({
+        doorsOpen: z.string().optional(),
+        start: z.string().optional(),
+        end: z.string().optional(),
+        doorsOpenLabel: z.enum(['DOORS_OPEN', 'GATES_OPEN']).optional(),
+    })
+        .default({}),
+    logo: z.object({ sourceUri: z.object({ uri: z.string() }) }).optional(),
+    wideLogo: z.object({ sourceUri: z.object({ uri: z.string() }) }).optional(),
+    heroImage: z.object({ sourceUri: z.object({ uri: z.string() }) }).optional(),
+});
+const NativeEventObject = z.object({
+    hexBackgroundColor: z.string(),
+    ticketNumber: z.string(),
+    ticketHolderName: z.string().optional(),
+    ticketType: LocalizedText.optional(),
+    seatInfo: z
+        .object({
+        seat: LocalizedText.optional(),
+        row: LocalizedText.optional(),
+        section: LocalizedText.optional(),
+        gate: LocalizedText.optional(),
+    })
+        .default({}),
+    textModulesData: NativeTextModules,
+    barcode: NativeBarcode,
+});
+const NativeLoyaltyClass = z.object({
+    issuerName: z.string(),
+    programName: z.string(),
+    hexBackgroundColor: z.string(),
+    programLogo: NativeImage.optional(),
+    wideProgramLogo: NativeImage.optional(),
+    heroImage: NativeImage.optional(),
+});
+const NativeLoyaltyObject = z.object({
+    accountId: z.string(),
+    accountName: z.string().optional(),
+    loyaltyPoints: z.object({
+        label: z.string(),
+        balance: z.object({ string: z.string() }),
+    }),
+    textModulesData: NativeTextModules,
+    barcode: NativeBarcode,
+});
+const NativeGoogle = z.object({
+    cardTitle: LocalizedText,
+    header: LocalizedText,
+    subheader: LocalizedText.optional(),
+    hexBackgroundColor: z.string(),
+    logo: NativeImage.optional(),
+    wideLogo: NativeImage.optional(),
+    heroImage: NativeImage.optional(),
+    textModulesData: z
+        .array(z.object({
+        id: z.string(),
+        header: z.string().default(''),
+        body: z.string(),
+    }))
+        .default([]),
+    barcode: z
+        .object({
+        type: z.string(),
+        value: z.string(),
+        alternateText: z.string().optional(),
+    })
+        .optional(),
+});
+const ALIGNMENTS = {
+    PKTextAlignmentLeft: 'left',
+    PKTextAlignmentCenter: 'center',
+    PKTextAlignmentRight: 'right',
+    PKTextAlignmentNatural: 'start',
+};
+const WALL_CLOCK = /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2})/;
+/**
+ * Roughly how Wallet shows a dated field (en-US, medium date and short time) in
+ * the timestamp's own offset, as `ignoresTimeZone` does. Other values pass through.
+ */
+function appleDateText(value, dateStyle, timeStyle) {
+    const match = WALL_CLOCK.exec(value);
+    if (!match || (!dateStyle && !timeStyle))
+        return value;
+    const [, y, mo, d, h, mi] = match.map(Number);
+    const at = Date.UTC(y, mo - 1, d, h, mi);
+    const showDate = dateStyle !== undefined && dateStyle !== 'PKDateStyleNone';
+    const showTime = timeStyle !== undefined && timeStyle !== 'PKDateStyleNone';
+    const date = new Intl.DateTimeFormat('en-US', { timeZone: 'UTC', dateStyle: 'medium' }).format(at);
+    const time = new Intl.DateTimeFormat('en-US', { timeZone: 'UTC', timeStyle: 'short' }).format(at);
+    if (showDate && showTime)
+        return `${date} at ${time}`;
+    return showDate ? date : showTime ? time : value;
+}
+export function applePreview(def, options) {
+    const rendered = renderApple(def, options);
+    const native = NativeApple.parse(rendered.passJson);
+    const fields = (items) => items.map(({ dateStyle, timeStyle, ...field }) => ({
+        ...field,
+        value: appleDateText(field.value, dateStyle, timeStyle),
+        textAlignment: field.textAlignment
+            ? ALIGNMENTS[field.textAlignment]
+            : undefined,
+    }));
+    const image = (slot) => Object.keys(rendered.files).some((name) => name === `${slot}.png` ||
+        name === `${slot}@2x.png` ||
+        name === `${slot}@3x.png`)
+        ? imageAssetId(def, slot)
+        : undefined;
+    const style = def.type === 'event_ticket'
+        ? 'eventTicket'
+        : def.type === 'stamp_card' || def.type === 'points_card'
+            ? 'storeCard'
+            : 'generic';
+    const layout = native[style];
+    if (!layout)
+        throw new Error(`Rendered Apple pass has no ${style} fields.`);
+    return {
+        platform: 'apple',
+        style,
+        organizationName: native.organizationName,
+        description: native.description,
+        logoText: native.logoText,
+        colors: {
+            background: native.backgroundColor,
+            foreground: native.foregroundColor,
+            label: native.labelColor ?? native.foregroundColor,
+        },
+        images: {
+            logo: image('logo'),
+            thumbnail: image('thumbnail'),
+            strip: image('strip'),
+            background: image('background'),
+        },
+        fields: {
+            header: fields(layout.headerFields),
+            primary: fields(layout.primaryFields),
+            secondary: fields(layout.secondaryFields),
+            auxiliary: fields(layout.auxiliaryFields),
+            back: fields(layout.backFields),
+        },
+        barcode: native.barcodes[0],
+        ...(native.posterGeneric
+            ? {
+                poster: {
+                    brand: def.apple.poster?.brand ?? 'logo',
+                    images: {
+                        artwork: imageAssetId(def, 'artwork'),
+                        logo: posterLogoAssetId(def),
+                    },
+                    fields: {
+                        header: fields(native.posterGeneric.headerFields),
+                        primary: fields(native.posterGeneric.primaryFields),
+                        footer: fields(native.posterGeneric.footerFields),
+                        additionalInfo: fields(native.posterGeneric.additionalInfoFields),
+                        back: fields(native.posterGeneric.backFields),
+                    },
+                },
+            }
+            : {}),
+        featuredActions: native.featuredActions.map((action) => ({
+            key: action.identifier,
+            type: action.type,
+            url: action.url,
+        })),
+    };
+}
+const SEAT_LABELS = { seat: 'Seat', row: 'Row', section: 'Section', gate: 'Gate' };
+/** Google's own labels, seen on device (2026-10-22); only the start's depends on the format. */
+function eventItemLabel(event, format, doorsOpenLabel) {
+    if (event === 'doorsOpen')
+        return doorsOpenLabel === 'GATES_OPEN' ? 'Gates open' : 'Doors open';
+    if (event === 'end')
+        return 'Event end time';
+    return format === 'date' ? 'Date' : format === 'time' ? 'Time' : 'Event start time';
+}
+function eventCardRows(def, cls, obj) {
+    if (def.type !== 'event_ticket' || !def.google.cardRows)
+        return undefined;
+    return def.google.cardRows.map((row) => row.flatMap((ref) => {
+        const item = resolveCardItem(ref, def.config.fields);
+        if (!item)
+            return [];
+        if (item.kind === 'seat') {
+            return [{ label: SEAT_LABELS[item.role], value: obj.seatInfo[item.role]?.defaultValue.value ?? '' }];
+        }
+        if (item.kind === 'event') {
+            return [
+                {
+                    label: eventItemLabel(item.event, item.format, cls.dateTime.doorsOpenLabel),
+                    value: cls.dateTime[item.event] ?? '',
+                    time: item.format,
+                },
+            ];
+        }
+        const module = obj.textModulesData.find((m) => m.id === ref);
+        return [{ label: module?.header ?? item.field.label, value: module?.body ?? '' }];
+    }));
+}
+function googleEventPreview(def, options) {
+    const payload = renderGoogle(def, options);
+    const cls = NativeEventClass.parse(payload.eventTicketClasses?.[0]);
+    const obj = NativeEventObject.parse(payload.eventTicketObjects?.[0]);
+    const assetId = (image) => image
+        ? Object.entries(options.assets).find(([, asset]) => asset.url === image.sourceUri.uri)?.[0]
+        : undefined;
+    const local = (text) => text?.defaultValue.value;
+    const seat = {
+        seat: local(obj.seatInfo.seat),
+        row: local(obj.seatInfo.row),
+        section: local(obj.seatInfo.section),
+        gate: local(obj.seatInfo.gate),
+    };
+    const textModules = obj.textModulesData.map((field) => ({
+        key: field.id,
+        label: field.header,
+        value: field.body,
+    }));
+    return {
+        platform: 'google',
+        style: 'eventTicket',
+        event: {
+            issuerName: cls.issuerName,
+            eventName: cls.eventName.defaultValue.value,
+            venue: cls.venue
+                ? { name: cls.venue.name.defaultValue.value, address: cls.venue.address.defaultValue.value }
+                : undefined,
+            dateTime: { doorsOpen: cls.dateTime.doorsOpen, start: cls.dateTime.start, end: cls.dateTime.end },
+            doorsOpenLabel: cls.dateTime.doorsOpenLabel === 'GATES_OPEN' ? 'gatesOpen' : 'doorsOpen',
+            timezone: def.event?.timezone,
+            seat: Object.fromEntries(Object.entries(seat).filter(([, v]) => v !== undefined)),
+            ticketHolderName: obj.ticketHolderName,
+            ticketType: local(obj.ticketType),
+            ticketNumber: obj.ticketNumber,
+            cardRows: eventCardRows(def, cls, obj),
+        },
+        cardTitle: cls.issuerName,
+        header: cls.eventName.defaultValue.value,
+        backgroundColor: obj.hexBackgroundColor,
+        foregroundColor: def.colors.foreground,
+        labelColor: def.colors.label ?? def.colors.foreground,
+        images: {
+            logo: assetId(cls.logo),
+            wideLogo: assetId(cls.wideLogo),
+            hero: assetId(cls.heroImage),
+        },
+        textModules,
+        barcode: obj.barcode
+            ? { format: obj.barcode.type, message: obj.barcode.value, altText: obj.barcode.alternateText }
+            : undefined,
+    };
+}
+function googleLoyaltyPreview(def, options) {
+    const payload = renderGoogle(def, options);
+    const cls = NativeLoyaltyClass.parse(payload.loyaltyClasses?.[0]);
+    const obj = NativeLoyaltyObject.parse(payload.loyaltyObjects?.[0]);
+    const assetId = (image) => image
+        ? Object.entries(options.assets).find(([, asset]) => asset.url === image.sourceUri.uri)?.[0]
+        : undefined;
+    return {
+        platform: 'google',
+        style: 'loyalty',
+        loyalty: {
+            issuerName: cls.issuerName,
+            programName: cls.programName,
+            balance: { label: obj.loyaltyPoints.label, value: obj.loyaltyPoints.balance.string },
+            accountName: obj.accountName,
+            accountId: obj.accountId,
+        },
+        cardTitle: cls.issuerName,
+        header: cls.programName,
+        backgroundColor: cls.hexBackgroundColor,
+        foregroundColor: def.colors.foreground,
+        labelColor: def.colors.label ?? def.colors.foreground,
+        images: {
+            logo: assetId(cls.programLogo),
+            wideLogo: assetId(cls.wideProgramLogo),
+            hero: assetId(cls.heroImage),
+        },
+        textModules: obj.textModulesData.map((field) => ({
+            key: field.id,
+            label: field.header,
+            value: field.body,
+        })),
+        barcode: obj.barcode
+            ? { format: obj.barcode.type, message: obj.barcode.value, altText: obj.barcode.alternateText }
+            : undefined,
+    };
+}
+export function googlePreview(def, options) {
+    if (def.type === 'event_ticket')
+        return googleEventPreview(def, options);
+    if (def.type === 'stamp_card' || def.type === 'points_card')
+        return googleLoyaltyPreview(def, options);
+    const native = NativeGoogle.parse(renderGoogle(def, options).genericObjects?.[0]);
+    const assetId = (image) => image
+        ? Object.entries(options.assets).find(([, asset]) => asset.url === image.sourceUri.uri)?.[0]
+        : undefined;
+    return {
+        platform: 'google',
+        style: 'generic',
+        cardTitle: native.cardTitle.defaultValue.value,
+        header: native.header.defaultValue.value,
+        subheader: native.subheader?.defaultValue.value,
+        backgroundColor: native.hexBackgroundColor,
+        foregroundColor: def.colors.foreground,
+        labelColor: def.colors.label ?? def.colors.foreground,
+        images: {
+            logo: assetId(native.logo),
+            wideLogo: assetId(native.wideLogo),
+            hero: assetId(native.heroImage),
+        },
+        textModules: native.textModulesData.map((field) => ({
+            key: field.id,
+            label: field.header,
+            value: field.body,
+        })),
+        barcode: native.barcode
+            ? {
+                format: native.barcode.type,
+                message: native.barcode.value,
+                altText: native.barcode.alternateText,
+            }
+            : undefined,
+    };
+}

package/dist/compiler/stamp-card.d.ts

@@ -0,0 +1,23 @@
+import type { TemplateDefinition } from '../contract/index.js';
+type StampCardDefinition = Extract<TemplateDefinition, {
+    type: 'stamp_card';
+}>;
+/** A stamp card's count and its drawn stamps, rendered for the platform being compiled. */
+export interface StampRender {
+    count: number;
+    appleStrip?: {
+        x2: Uint8Array;
+        x3: Uint8Array;
+    };
+    /** The poster art with the stamps drawn in, while the poster is on. */
+    appleArtwork?: Uint8Array;
+    googleHeroUrl?: string;
+}
+/** Previews show a card about half full. */
+export declare function previewStampCount(total: number): number;
+/**
+ * The stamps a compile uses. Validation compiles (previews, update checks) pass
+ * none and get stand-ins: the image bytes and URL only matter when signing.
+ */
+export declare function stampRenderFor(def: StampCardDefinition, stamps: StampRender | undefined, mode: 'preview' | 'issue'): Required<StampRender>;
+export {};

package/dist/compiler/stamp-card.js

@@ -0,0 +1,19 @@
+const PLACEHOLDER_STRIP = new Uint8Array([0]);
+const PLACEHOLDER_ARTWORK = new Uint8Array([0]);
+const PLACEHOLDER_HERO_URL = 'https://assets.tapace.example/stamps.png';
+/** Previews show a card about half full. */
+export function previewStampCount(total) {
+    return Math.ceil(total / 2);
+}
+/**
+ * The stamps a compile uses. Validation compiles (previews, update checks) pass
+ * none and get stand-ins: the image bytes and URL only matter when signing.
+ */
+export function stampRenderFor(def, stamps, mode) {
+    return {
+        count: stamps?.count ?? (mode === 'preview' ? previewStampCount(def.config.stamps.total) : 0),
+        appleStrip: stamps?.appleStrip ?? { x2: PLACEHOLDER_STRIP, x3: PLACEHOLDER_STRIP },
+        appleArtwork: stamps?.appleArtwork ?? PLACEHOLDER_ARTWORK,
+        googleHeroUrl: stamps?.googleHeroUrl ?? PLACEHOLDER_HERO_URL,
+    };
+}

package/dist/compiler/template-preview.d.ts

@@ -0,0 +1,34 @@
+import { type CompileIssue } from './passmint-compiler.js';
+import { type ApplePreview, type GooglePreview } from './preview-model.js';
+import { type FieldValue, type TemplateDefinition, type TemplateTypeName } from '../contract/index.js';
+export interface TemplatePreview {
+    requiredFields: string[];
+    issues: CompileIssue[];
+    apple?: ApplePreview;
+    google?: GooglePreview;
+}
+export interface AssetSize {
+    width: number;
+    height: number;
+}
+export interface TemplatePreviewOptions {
+    sampleValues?: Record<string, FieldValue>;
+    mode?: 'preview' | 'issue';
+    barcodeValue?: string;
+    actionLinks?: Record<string, string>;
+    stampCount?: number;
+    pointsBalance?: number;
+    allWallets?: boolean;
+    /** Sizes of the referenced images; a missing size skips that image's size check. */
+    assetSizes?: ReadonlyMap<string, AssetSize>;
+}
+export type ParsedPreviewInput = {
+    definition: TemplateDefinition;
+    issues?: undefined;
+} | {
+    definition?: undefined;
+    issues: CompileIssue[];
+};
+export declare function parsePreviewInput(declaredType: TemplateTypeName, input: unknown, organizationName: string, event?: unknown): ParsedPreviewInput;
+/** Apple and Google previews of a parsed definition. Stamp cards' drawn stamps are added by the caller. */
+export declare function buildTemplatePreview(def: TemplateDefinition, options?: TemplatePreviewOptions): TemplatePreview;

package/dist/compiler/template-preview.js

@@ -0,0 +1,125 @@
+import { ZodError } from 'zod';
+import { placeholderAssets, toCompileIssues } from './passmint-compiler.js';
+import { applePreview, googlePreview } from './preview-model.js';
+import { EventDetailsSchema, TemplateValidationError, imageAssetId, parseTemplateDefinition, posterEnabled, previewFieldValues, referencedAssetIds, requiredFieldKeys, } from '../contract/index.js';
+/** Google's minimum for the logo it crops into a circle (Wallet brand guidelines). */
+const GOOGLE_LOGO_MIN_SIZE = 660;
+const GOOGLE_WIDE_LOGO_MIN_HEIGHT = 400;
+const GOOGLE_WIDE_LOGO_RATIO = 16 / 5;
+const GOOGLE_WIDE_LOGO_RATIO_TOLERANCE = 0.1;
+// Wallet fills the 5:7 (358×501 pt) poster card and crops other shapes from the
+// centre (device tests AC1–AC3).
+const POSTER_ARTWORK_RATIO = 5 / 7;
+const POSTER_ARTWORK_RATIO_TOLERANCE = 0.02;
+export function parsePreviewInput(declaredType, input, organizationName, event) {
+    // Signing overlays the live event details on the definition; they are never part of it.
+    const isObject = !!input && typeof input === 'object' && !Array.isArray(input);
+    const { event: overlaid, ...rest } = isObject ? input : { event: undefined };
+    const body = isObject ? { ...rest, organizationName } : input;
+    try {
+        let definition = parseTemplateDefinition(declaredType, body);
+        if (definition.type === 'event_ticket') {
+            const details = event ?? overlaid;
+            if (details !== undefined)
+                definition = { ...definition, event: EventDetailsSchema.parse(details) };
+        }
+        return { definition };
+    }
+    catch (err) {
+        if (err instanceof ZodError)
+            return {
+                issues: err.issues.map((i) => ({
+                    platform: 'template',
+                    path: ['event', ...i.path].join('.'),
+                    message: i.message,
+                })),
+            };
+        if (err instanceof TemplateValidationError)
+            return {
+                issues: err.issues.map((i) => ({
+                    platform: 'template',
+                    path: i.path.join('.'),
+                    message: i.message,
+                })),
+            };
+        throw err;
+    }
+}
+/** Apple and Google previews of a parsed definition. Stamp cards' drawn stamps are added by the caller. */
+export function buildTemplatePreview(def, options = {}) {
+    const { sampleValues = {}, mode = 'preview', allWallets = false, assetSizes = new Map() } = options;
+    const ids = referencedAssetIds(def);
+    // In preview mode callers pass public field keys; resolve them to field ids
+    // (assigning ephemeral ids to unsaved fields) for the id-keyed compiler.
+    const compileDef = mode === 'preview' ? previewFieldValues(def, sampleValues) : { def, values: sampleValues };
+    // Renderers need asset references; previewing never downloads or signs image bytes.
+    const compileOptions = {
+        assets: placeholderAssets(ids),
+        values: compileDef.values,
+        barcodeValue: options.barcodeValue,
+        actionLinks: options.actionLinks,
+        mode,
+        ...(options.stampCount !== undefined ? { stamps: { count: options.stampCount } } : {}),
+        ...(options.pointsBalance !== undefined ? { points: options.pointsBalance } : {}),
+    };
+    const result = { requiredFields: requiredFieldKeys(def), issues: [] };
+    if (def.platforms.apple || allWallets) {
+        try {
+            result.apple = applePreview(compileDef.def, compileOptions);
+            if (['PKBarcodeFormatQR', 'PKBarcodeFormatAztec'].includes(result.apple.barcode?.format ?? '') &&
+                result.apple.fields.secondary.length + result.apple.fields.auxiliary.length > 4) {
+                result.issues.push({
+                    platform: 'apple',
+                    path: 'config.layouts.standard',
+                    message: 'With a square barcode, Apple passes display at most four secondary and auxiliary fields combined.',
+                });
+            }
+            const artworkId = posterEnabled(def) ? imageAssetId(def, 'artwork') : undefined;
+            const artwork = artworkId ? assetSizes.get(artworkId) : undefined;
+            if (artwork &&
+                Math.abs(artwork.width / artwork.height / POSTER_ARTWORK_RATIO - 1) > POSTER_ARTWORK_RATIO_TOLERANCE)
+                result.issues.push({
+                    platform: 'apple',
+                    path: 'images.artwork',
+                    message: 'Wallet fills the 5:7 poster and crops the rest of the artwork from the centre. Use a 5:7 image, such as 1074×1504 px, to keep its edges.',
+                });
+        }
+        catch (err) {
+            if (def.platforms.apple)
+                result.issues.push(...toCompileIssues('apple', err));
+        }
+    }
+    if (def.platforms.google || allWallets) {
+        try {
+            result.google = googlePreview(compileDef.def, compileOptions);
+            if (result.google.textModules.length > 10)
+                result.issues.push({
+                    platform: 'google',
+                    path: 'config.layouts.standard',
+                    message: 'Google displays at most ten object text modules. Reduce the number of fields.',
+                });
+            const googleLogo = def.google.logoAssetId ? assetSizes.get(def.google.logoAssetId) : undefined;
+            if (googleLogo && (googleLogo.width !== googleLogo.height || googleLogo.width < GOOGLE_LOGO_MIN_SIZE))
+                result.issues.push({
+                    platform: 'google',
+                    path: 'google.logoAssetId',
+                    message: `Google crops the logo into a circle. Use a square image of at least ${GOOGLE_LOGO_MIN_SIZE}×${GOOGLE_LOGO_MIN_SIZE} px with a full-bleed background.`,
+                });
+            const wideLogo = def.google.wideLogoAssetId ? assetSizes.get(def.google.wideLogoAssetId) : undefined;
+            if (wideLogo &&
+                (wideLogo.height < GOOGLE_WIDE_LOGO_MIN_HEIGHT ||
+                    Math.abs(wideLogo.width / wideLogo.height / GOOGLE_WIDE_LOGO_RATIO - 1) > GOOGLE_WIDE_LOGO_RATIO_TOLERANCE))
+                result.issues.push({
+                    platform: 'google',
+                    path: 'google.wideLogoAssetId',
+                    message: `Google fits the wide logo into its header. Use a transparent 16:5 image of at least ${GOOGLE_WIDE_LOGO_MIN_HEIGHT} px tall, such as 1280×400 px.`,
+                });
+        }
+        catch (err) {
+            if (def.platforms.google)
+                result.issues.push(...toCompileIssues('google', err));
+        }
+    }
+    result.issues = result.issues.filter((issue) => (issue.platform !== 'apple' && issue.platform !== 'google') || def.platforms[issue.platform]);
+    return result;
+}