@localizeaso/cli 0.1.0-preview.0

package/packages/asc-shared/dist/aso-keyword-map.js

@@ -0,0 +1,292 @@
+function isRecord(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+function cleanString(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function normalizeLocaleKey(value) {
+    return value.trim().replace(/_/g, '-');
+}
+function normalizeKeyword(value) {
+    return String(value ?? '')
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function finiteRoundedNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? Math.round(value) : undefined;
+}
+function normalizeKeywordContext(value) {
+    if (!isRecord(value))
+        return { sources: [], keywords: {}, rows: [] };
+    const sources = Array.isArray(value.sources)
+        ? Array.from(new Set(value.sources.map(cleanString).filter(Boolean)))
+        : [];
+    const keywords = {};
+    if (isRecord(value.keywords)) {
+        for (const [locale, rawKeywords] of Object.entries(value.keywords)) {
+            if (!Array.isArray(rawKeywords))
+                continue;
+            const normalizedLocale = normalizeLocaleKey(locale);
+            keywords[normalizedLocale] = Array.from(new Set(rawKeywords.map(cleanString).filter(Boolean)));
+        }
+    }
+    const rows = [];
+    if (Array.isArray(value.rows)) {
+        for (const row of value.rows) {
+            if (!isRecord(row))
+                continue;
+            const locale = normalizeLocaleKey(cleanString(row.locale));
+            const keyword = cleanString(row.keyword);
+            if (!locale || !keyword)
+                continue;
+            rows.push({
+                locale,
+                keyword,
+                normalizedKeyword: normalizeKeyword(keyword),
+                popularity: finiteRoundedNumber(row.popularity),
+                difficulty: finiteRoundedNumber(row.difficulty),
+                isPreferred: typeof row.isPreferred === 'boolean' ? row.isPreferred : undefined,
+                source: cleanString(row.source) || undefined,
+            });
+        }
+    }
+    for (const [locale, localeKeywords] of Object.entries(keywords)) {
+        for (const keyword of localeKeywords) {
+            const normalizedKeyword = normalizeKeyword(keyword);
+            if (rows.some((row) => row.locale === locale && row.normalizedKeyword === normalizedKeyword)) {
+                continue;
+            }
+            rows.push({ locale, keyword, normalizedKeyword });
+        }
+    }
+    return { sources, keywords, rows };
+}
+function fieldIndexedForAppleSearch(field) {
+    const normalizedField = field.toLowerCase();
+    return ['name', 'title', 'subtitle', 'keywords', 'keyword', 'keywordfield', 'screenshotcaption'].includes(normalizedField.replace(/[^a-z]/g, ''));
+}
+function indexedFieldNote(field) {
+    return fieldIndexedForAppleSearch(field)
+        ? 'Indexed by Apple search signals.'
+        : 'Not a primary Apple search keyword field; use as conversion/context signal.';
+}
+function matchKeywordInValue(value, keyword) {
+    const normalizedKeyword = normalizeKeyword(keyword);
+    if (!normalizedKeyword)
+        return [];
+    const normalizedValue = normalizeKeyword(value);
+    const positions = [];
+    let fromIndex = 0;
+    while (fromIndex < normalizedValue.length) {
+        const matchIndex = normalizedValue.indexOf(normalizedKeyword, fromIndex);
+        if (matchIndex === -1)
+            break;
+        positions.push({
+            start: matchIndex,
+            end: matchIndex + normalizedKeyword.length,
+            text: value.slice(matchIndex, matchIndex + normalizedKeyword.length),
+        });
+        fromIndex = matchIndex + Math.max(1, normalizedKeyword.length);
+    }
+    return positions;
+}
+function issue(params) {
+    return {
+        severity: params.severity ?? 'warning',
+        code: params.code,
+        message: params.message,
+        locale: params.locale,
+        field: params.field,
+        keyword: params.keyword,
+    };
+}
+export function buildAsoKeywordDetectionReport(input) {
+    const keywordContext = normalizeKeywordContext(input.keywordContext);
+    const locales = Array.from(new Set([
+        ...Object.keys(input.metadataByLocale).map(normalizeLocaleKey),
+        ...keywordContext.rows.map((row) => row.locale),
+        ...Object.keys(keywordContext.keywords).map(normalizeLocaleKey),
+    ]))
+        .filter(Boolean)
+        .sort();
+    const globalWarnings = [];
+    const globalErrors = [];
+    if (!keywordContext.rows.length) {
+        globalWarnings.push(issue({
+            code: 'keyword_context_missing',
+            message: 'No keyword context rows are attached; ASO keyword detection can only report metadata fields.',
+        }));
+    }
+    const localeReports = locales.map((locale) => {
+        const metadataFields = input.metadataByLocale[locale] ?? {};
+        const keywords = keywordContext.rows.filter((row) => row.locale === locale);
+        const fieldReports = [];
+        const warnings = [];
+        const errors = [];
+        if (!Object.keys(metadataFields).length) {
+            errors.push(issue({
+                severity: 'error',
+                code: 'metadata_snapshot_missing',
+                message: `No metadata snapshot fields were found for ${locale}.`,
+                locale,
+            }));
+        }
+        if (!keywords.length) {
+            warnings.push(issue({
+                code: 'locale_keyword_context_missing',
+                message: `No ASO keyword rows were found for ${locale}.`,
+                locale,
+            }));
+        }
+        for (const [field, rawValue] of Object.entries(metadataFields).sort(([a], [b]) => a.localeCompare(b))) {
+            const value = rawValue === null || rawValue === undefined ? '' : String(rawValue);
+            const fieldWarnings = [];
+            const matches = [];
+            for (const keyword of keywords) {
+                const positions = matchKeywordInValue(value, keyword.keyword);
+                if (!positions.length)
+                    continue;
+                matches.push({
+                    ...keyword,
+                    matchCount: positions.length,
+                    positions,
+                });
+                if (positions.length > 1) {
+                    fieldWarnings.push(issue({
+                        code: 'keyword_repeated_in_field',
+                        message: `Keyword "${keyword.keyword}" appears ${positions.length} times in ${field}.`,
+                        locale,
+                        field,
+                        keyword: keyword.keyword,
+                    }));
+                }
+            }
+            if (!fieldIndexedForAppleSearch(field) && matches.length) {
+                fieldWarnings.push(issue({
+                    severity: 'info',
+                    code: 'non_indexed_field_keyword_match',
+                    message: `${field} contains matched keyword context but is not a primary Apple indexed metadata field.`,
+                    locale,
+                    field,
+                }));
+            }
+            fieldReports.push({
+                field,
+                value,
+                indexedForAppleSearch: fieldIndexedForAppleSearch(field),
+                notes: [indexedFieldNote(field)],
+                matches,
+                warnings: fieldWarnings,
+            });
+            warnings.push(...fieldWarnings.filter((warning) => warning.severity !== 'info'));
+        }
+        const coverage = keywords.map((keyword) => {
+            const fields = fieldReports
+                .map((field) => {
+                const match = field.matches.find((candidate) => candidate.normalizedKeyword === keyword.normalizedKeyword);
+                return match
+                    ? { field: field.field, matchCount: match.matchCount, positions: match.positions }
+                    : null;
+            })
+                .filter((field) => Boolean(field));
+            const keywordWarnings = [];
+            if (!fields.length) {
+                keywordWarnings.push(issue({
+                    code: 'keyword_not_detected',
+                    message: `Keyword "${keyword.keyword}" is not detected in any metadata field for ${locale}.`,
+                    locale,
+                    keyword: keyword.keyword,
+                }));
+            }
+            if (fields.length > 1) {
+                keywordWarnings.push(issue({
+                    code: 'keyword_detected_in_multiple_fields',
+                    message: `Keyword "${keyword.keyword}" appears in ${fields.length} metadata fields for ${locale}.`,
+                    locale,
+                    keyword: keyword.keyword,
+                }));
+            }
+            if (typeof keyword.difficulty === 'number' && keyword.difficulty >= 70) {
+                keywordWarnings.push(issue({
+                    severity: 'info',
+                    code: 'high_difficulty_keyword',
+                    message: `Keyword "${keyword.keyword}" has high difficulty (${keyword.difficulty}).`,
+                    locale,
+                    keyword: keyword.keyword,
+                }));
+            }
+            if (typeof keyword.popularity === 'number' && keyword.popularity <= 20) {
+                keywordWarnings.push(issue({
+                    severity: 'info',
+                    code: 'low_popularity_keyword',
+                    message: `Keyword "${keyword.keyword}" has low popularity (${keyword.popularity}).`,
+                    locale,
+                    keyword: keyword.keyword,
+                }));
+            }
+            warnings.push(...keywordWarnings.filter((warning) => warning.severity !== 'info'));
+            return {
+                ...keyword,
+                detected: fields.length > 0,
+                fields,
+                warnings: keywordWarnings,
+            };
+        });
+        return {
+            locale,
+            fields: fieldReports,
+            keywordCoverage: coverage,
+            unassignedKeywords: coverage.filter((keyword) => !keyword.detected),
+            warnings,
+            errors,
+        };
+    });
+    const allWarnings = [
+        ...globalWarnings,
+        ...localeReports.flatMap((locale) => locale.warnings),
+    ];
+    const allErrors = [
+        ...globalErrors,
+        ...localeReports.flatMap((locale) => locale.errors),
+    ];
+    const fieldCount = localeReports.reduce((sum, locale) => sum + locale.fields.length, 0);
+    const keywordKeys = new Set(localeReports.flatMap((locale) => locale.keywordCoverage.map((keyword) => `${locale.locale}|${keyword.normalizedKeyword}`)));
+    const detectedKeywordCount = localeReports.reduce((sum, locale) => sum + locale.keywordCoverage.filter((keyword) => keyword.detected).length, 0);
+    const unassignedKeywordCount = localeReports.reduce((sum, locale) => sum + locale.unassignedKeywords.length, 0);
+    return {
+        kind: 'localizeaso_aso_keyword_detection_report',
+        version: 1,
+        surface: input.surface,
+        generatedAt: input.generatedAt ?? new Date().toISOString(),
+        agentCompatibility: {
+            audience: 'any_coding_agent',
+            protocol: 'provider_neutral_json',
+            requiresHumanApprovalBeforeApply: true,
+            notes: [
+                'Any coding agent can consume this report; it is not tied to a specific agent vendor or hosted LocalizeASO model.',
+                'Use keywordCoverage, fields.matches, unassignedKeywords, warnings, and errors as proposal context only.',
+                'The report is read-only and never grants approval, apply, publish, or App Store Connect submit permission.',
+            ],
+        },
+        agents: input.agents ?? ['any-coding-agent'],
+        source: {
+            metadataSnapshotKeys: input.metadataSnapshotKeys ?? [],
+            keywordContextSources: keywordContext.sources,
+        },
+        summary: {
+            localeCount: localeReports.length,
+            fieldCount,
+            keywordCount: keywordKeys.size,
+            detectedKeywordCount,
+            unassignedKeywordCount,
+            warningCount: allWarnings.length,
+            errorCount: allErrors.length,
+        },
+        locales: localeReports,
+        warnings: allWarnings,
+        errors: allErrors,
+    };
+}

package/packages/asc-shared/dist/constants.d.ts

@@ -0,0 +1,15 @@
+export declare const APP_STORE_LOCALES: {
+    code: string;
+    name: string;
+}[];
+export declare const LOCALE_TO_REGION_CODE: Record<string, string>;
+export declare const ASC_LOCALE_ALIASES: Record<string, string>;
+export declare const FULL_EDIT_MODE: readonly ["PREPARE_FOR_SUBMISSION", "METADATA_REJECTED", "WAITING_FOR_EXPORT_COMPLIANCE", "REJECTED", "DEVELOPER_REJECTED"];
+export declare const CAN_CREATE_NEW_VERSION: readonly ["READY_FOR_DISTRIBUTION"];
+export declare const APP_TITLE_STYLE_VALUES: readonly ["appname_colon_main_keyword", "main_keyword_colon_appname", "main_keyword_dash_appname", "appname_dash_main_keyword", "main_keywords_only"];
+export type AppTitleStyle = (typeof APP_TITLE_STYLE_VALUES)[number];
+export declare const DEFAULT_APP_TITLE_STYLE: AppTitleStyle;
+export declare const APP_TITLE_CASING_VALUES: readonly ["language_optimized", "capitalize_each_word", "all_lowercase"];
+export type AppTitleCasing = (typeof APP_TITLE_CASING_VALUES)[number];
+export declare const DEFAULT_APP_TITLE_CASING: AppTitleCasing;
+//# sourceMappingURL=constants.d.ts.map

package/packages/asc-shared/dist/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iBAAiB;;;GAwC7B,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAwCxD,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAyBrD,CAAC;AAEF,eAAO,MAAM,cAAc,6HAMjB,CAAC;AAEX,eAAO,MAAM,sBAAsB,qCAAsC,CAAC;AAE1E,eAAO,MAAM,sBAAsB,uJAMzB,CAAC;AAEX,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,sBAAsB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEpE,eAAO,MAAM,uBAAuB,EAAE,aAA4C,CAAC;AAEnF,eAAO,MAAM,uBAAuB,0EAI1B,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEtE,eAAO,MAAM,wBAAwB,EAAE,cAAqC,CAAC"}

package/packages/asc-shared/dist/constants.js

@@ -0,0 +1,130 @@
+export const APP_STORE_LOCALES = [
+    { code: 'ar-SA', name: 'Arabic' },
+    { code: 'ca', name: 'Catalan' },
+    { code: 'cs', name: 'Czech' },
+    { code: 'da', name: 'Danish' },
+    { code: 'de-DE', name: 'German' },
+    { code: 'el', name: 'Greek' },
+    { code: 'en-AU', name: 'English (Australia)' },
+    { code: 'en-CA', name: 'English (Canada)' },
+    { code: 'en-GB', name: 'English (UK)' },
+    { code: 'en-US', name: 'English (US)' },
+    { code: 'es-ES', name: 'Spanish (Spain)' },
+    { code: 'es-MX', name: 'Spanish (Mexico)' },
+    { code: 'fi', name: 'Finnish' },
+    { code: 'fr-CA', name: 'French (Canada)' },
+    { code: 'fr-FR', name: 'French (France)' },
+    { code: 'he', name: 'Hebrew' },
+    { code: 'hi', name: 'Hindi' },
+    { code: 'hr', name: 'Croatian' },
+    { code: 'hu', name: 'Hungarian' },
+    { code: 'id', name: 'Indonesian' },
+    { code: 'it', name: 'Italian' },
+    { code: 'ja', name: 'Japanese' },
+    { code: 'ko', name: 'Korean' },
+    { code: 'ms', name: 'Malay' },
+    { code: 'nl-NL', name: 'Dutch' },
+    { code: 'no', name: 'Norwegian' },
+    { code: 'pl', name: 'Polish' },
+    { code: 'pt-BR', name: 'Portuguese (Brazil)' },
+    { code: 'pt-PT', name: 'Portuguese (Portugal)' },
+    { code: 'ro', name: 'Romanian' },
+    { code: 'ru', name: 'Russian' },
+    { code: 'sk', name: 'Slovak' },
+    { code: 'sv', name: 'Swedish' },
+    { code: 'th', name: 'Thai' },
+    { code: 'tr', name: 'Turkish' },
+    { code: 'uk', name: 'Ukrainian' },
+    { code: 'vi', name: 'Vietnamese' },
+    { code: 'zh-Hans', name: 'Chinese (Simplified)' },
+    { code: 'zh-Hant', name: 'Chinese (Traditional)' },
+];
+export const LOCALE_TO_REGION_CODE = {
+    'ar-SA': 'SA',
+    ca: 'ES',
+    cs: 'CZ',
+    da: 'DK',
+    'de-DE': 'DE',
+    el: 'GR',
+    'en-AU': 'AU',
+    'en-CA': 'CA',
+    'en-GB': 'GB',
+    'en-US': 'US',
+    'es-ES': 'ES',
+    'es-MX': 'MX',
+    fi: 'FI',
+    'fr-CA': 'CA',
+    'fr-FR': 'FR',
+    he: 'IL',
+    hi: 'IN',
+    hr: 'HR',
+    hu: 'HU',
+    id: 'ID',
+    it: 'IT',
+    ja: 'JP',
+    ko: 'KR',
+    ms: 'MY',
+    'nl-NL': 'NL',
+    no: 'NO',
+    pl: 'PL',
+    'pt-BR': 'BR',
+    'pt-PT': 'PT',
+    ro: 'RO',
+    ru: 'RU',
+    sk: 'SK',
+    sv: 'SE',
+    th: 'TH',
+    tr: 'TR',
+    uk: 'UA',
+    vi: 'VN',
+    'zh-Hans': 'CN',
+    'zh-Hant': 'TW',
+};
+export const ASC_LOCALE_ALIASES = {
+    'ca-ES': 'ca',
+    'cs-CZ': 'cs',
+    'da-DK': 'da',
+    'el-GR': 'el',
+    'fi-FI': 'fi',
+    'he-IL': 'he',
+    'hi-IN': 'hi',
+    'hr-HR': 'hr',
+    'hu-HU': 'hu',
+    'id-ID': 'id',
+    'it-IT': 'it',
+    'ja-JP': 'ja',
+    'ko-KR': 'ko',
+    'ms-MY': 'ms',
+    'no-NO': 'no',
+    'pl-PL': 'pl',
+    'ro-RO': 'ro',
+    'ru-RU': 'ru',
+    'sk-SK': 'sk',
+    'sv-SE': 'sv',
+    'th-TH': 'th',
+    'tr-TR': 'tr',
+    'uk-UA': 'uk',
+    'vi-VN': 'vi',
+};
+export const FULL_EDIT_MODE = [
+    'PREPARE_FOR_SUBMISSION',
+    'METADATA_REJECTED',
+    'WAITING_FOR_EXPORT_COMPLIANCE',
+    'REJECTED',
+    'DEVELOPER_REJECTED',
+];
+export const CAN_CREATE_NEW_VERSION = ['READY_FOR_DISTRIBUTION'];
+export const APP_TITLE_STYLE_VALUES = [
+    'appname_colon_main_keyword',
+    'main_keyword_colon_appname',
+    'main_keyword_dash_appname',
+    'appname_dash_main_keyword',
+    'main_keywords_only',
+];
+export const DEFAULT_APP_TITLE_STYLE = 'main_keyword_colon_appname';
+export const APP_TITLE_CASING_VALUES = [
+    'language_optimized',
+    'capitalize_each_word',
+    'all_lowercase',
+];
+export const DEFAULT_APP_TITLE_CASING = 'language_optimized';

package/packages/asc-shared/dist/cross-localization.d.ts

@@ -0,0 +1,29 @@
+export type CrossLocalizationTier = 'primary_exact' | 'primary_language' | 'target_exact' | 'target_language' | 'cross_exact' | 'cross_language';
+export declare const CROSS_LOCALIZATION_TIER_WEIGHT: Record<CrossLocalizationTier, number>;
+export declare function resolveCrossLocalizedLocales(args: {
+    targetLocale: string;
+    primaryLocale?: string | null;
+}): {
+    primaryLocale: string;
+    targetLocale: string;
+    crossExactLocales: Set<string>;
+    crossLanguageCodes: Set<string>;
+};
+export declare function resolveCrossLocalizationTier(args: {
+    keywordLocale: string;
+    targetLocale: string;
+    primaryLocale?: string | null;
+    includeCrossLocalization?: boolean;
+}): CrossLocalizationTier | null;
+export declare function selectCrossLocalizedRows<T extends {
+    locale: string;
+}>(rows: T[] | undefined, args: {
+    targetLocale: string;
+    primaryLocale?: string | null;
+    includeCrossLocalization?: boolean;
+}): {
+    row: T;
+    tier: CrossLocalizationTier;
+    weight: number;
+}[];
+//# sourceMappingURL=cross-localization.d.ts.map

package/packages/asc-shared/dist/cross-localization.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cross-localization.d.ts","sourceRoot":"","sources":["../src/cross-localization.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,qBAAqB,GAC7B,eAAe,GACf,kBAAkB,GAClB,cAAc,GACd,iBAAiB,GACjB,aAAa,GACb,gBAAgB,CAAC;AAErB,eAAO,MAAM,8BAA8B,EAAE,MAAM,CAAC,qBAAqB,EAAE,MAAM,CAOhF,CAAC;AA6GF,wBAAgB,4BAA4B,CAAC,IAAI,EAAE;IACjD,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;;;;;EA+BA;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE;IACjD,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACpC,GAAG,qBAAqB,GAAG,IAAI,CAoC/B;AAED,wBAAgB,wBAAwB,CAAC,CAAC,SAAS;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,EACnE,IAAI,EAAE,CAAC,EAAE,GAAG,SAAS,EACrB,IAAI,EAAE;IACJ,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9B,wBAAwB,CAAC,EAAE,OAAO,CAAC;CACpC;SAE4C,CAAC;UAAQ,qBAAqB;YAAU,MAAM;IAoB5F"}

package/packages/asc-shared/dist/cross-localization.js

@@ -0,0 +1,189 @@
+import { ASC_LOCALES, normalizeAscLocale } from './locales.js';
+export const CROSS_LOCALIZATION_TIER_WEIGHT = {
+    primary_exact: 1200,
+    primary_language: 1050,
+    target_exact: 900,
+    target_language: 760,
+    cross_exact: 560,
+    cross_language: 420,
+};
+// Cross-localization locale graph derived from the ASO reference matrix:
+// https://aso.dev/metadata/cross-localization/
+// The graph encodes locale-to-locale indexing relationships (default/additional).
+const RAW_CROSS_LOCALE_GRAPH = {
+    'ar-SA': ['en-GB', 'en-US', 'fr-FR', 'zh-Hans', 'zh-Hant', 'vi'],
+    ca: ['es-ES', 'en-GB'],
+    cs: ['en-GB'],
+    da: ['en-GB'],
+    'de-DE': ['en-GB', 'fr-FR', 'it'],
+    el: ['en-GB'],
+    'en-AU': ['ar-SA', 'zh-Hans', 'zh-Hant', 'vi', 'en-GB'],
+    'en-CA': ['fr-CA', 'en-US', 'en-GB'],
+    'en-GB': ASC_LOCALES.filter((locale) => locale !== 'en-GB'),
+    'en-US': ['ar-SA', 'zh-Hans', 'zh-Hant', 'fr-FR', 'ko', 'pt-BR', 'ru', 'es-MX', 'vi', 'ja'],
+    'es-ES': ['ca', 'en-GB'],
+    'es-MX': ['en-GB', 'en-US', 'pt-BR', 'fr-FR'],
+    fi: ['en-GB'],
+    'fr-CA': ['en-CA', 'en-US', 'en-GB'],
+    'fr-FR': [
+        'en-GB',
+        'ar-SA',
+        'de-DE',
+        'it',
+        'ja',
+        'ko',
+        'pt-BR',
+        'ru',
+        'zh-Hans',
+        'es-MX',
+        'zh-Hant',
+        'vi',
+        'nl-NL',
+    ],
+    he: ['en-GB'],
+    hi: ['en-GB'],
+    hr: ['en-GB'],
+    hu: ['en-GB'],
+    id: ['en-GB'],
+    it: ['en-GB', 'de-DE', 'fr-FR'],
+    ja: ['en-US', 'en-GB', 'fr-FR'],
+    ko: ['en-US', 'en-GB', 'fr-FR'],
+    ms: ['en-GB'],
+    'nl-NL': ['en-GB', 'fr-FR'],
+    no: ['en-GB'],
+    pl: ['en-GB'],
+    'pt-BR': ['en-US', 'en-GB', 'es-MX', 'fr-FR'],
+    'pt-PT': ['en-GB'],
+    ro: ['en-GB'],
+    ru: ['en-US', 'en-GB', 'fr-FR'],
+    sk: ['en-GB'],
+    sv: ['en-GB'],
+    th: ['en-GB'],
+    tr: ['en-GB'],
+    uk: ['en-GB'],
+    vi: ['en-US', 'en-AU', 'en-GB', 'fr-FR'],
+    'zh-Hans': ['en-US', 'en-GB', 'fr-FR', 'zh-Hant'],
+    'zh-Hant': ['en-US', 'en-GB', 'fr-FR', 'zh-Hans'],
+};
+const ASC_LOCALE_SET = new Set(ASC_LOCALES.map((locale) => normalizeAscLocale(locale)));
+function localeLanguage(locale) {
+    return normalizeAscLocale(locale).split('-')[0] ?? '';
+}
+function isLanguageOnly(locale) {
+    const normalized = normalizeAscLocale(locale);
+    return normalized.length > 0 && !normalized.includes('-');
+}
+function normalizeGraph(graph) {
+    const normalized = {};
+    for (const locale of ASC_LOCALES) {
+        const normalizedLocale = normalizeAscLocale(locale);
+        normalized[normalizedLocale] = new Set();
+    }
+    for (const [source, targets] of Object.entries(graph)) {
+        const sourceLocale = normalizeAscLocale(source);
+        if (!sourceLocale || !ASC_LOCALE_SET.has(sourceLocale))
+            continue;
+        for (const rawTarget of targets) {
+            const targetLocale = normalizeAscLocale(rawTarget);
+            if (!targetLocale || !ASC_LOCALE_SET.has(targetLocale))
+                continue;
+            normalized[sourceLocale]?.add(targetLocale);
+            normalized[targetLocale]?.add(sourceLocale);
+        }
+    }
+    return Object.fromEntries(Object.entries(normalized).map(([locale, connected]) => [locale, Array.from(connected)]));
+}
+const CROSS_LOCALE_GRAPH = normalizeGraph(RAW_CROSS_LOCALE_GRAPH);
+function getSameLanguageLocales(locale) {
+    const language = localeLanguage(locale);
+    if (!language)
+        return new Set();
+    return new Set(ASC_LOCALES.map((entry) => normalizeAscLocale(entry)).filter((entry) => localeLanguage(entry) === language));
+}
+export function resolveCrossLocalizedLocales(args) {
+    const targetLocale = normalizeAscLocale(args.targetLocale);
+    if (!targetLocale) {
+        return {
+            primaryLocale: '',
+            targetLocale: '',
+            crossExactLocales: new Set(),
+            crossLanguageCodes: new Set(),
+        };
+    }
+    const primaryLocale = normalizeAscLocale(args.primaryLocale ?? '');
+    const crossExactLocales = new Set();
+    for (const candidate of CROSS_LOCALE_GRAPH[targetLocale] ?? []) {
+        crossExactLocales.add(candidate);
+    }
+    for (const candidate of getSameLanguageLocales(targetLocale)) {
+        if (candidate !== targetLocale)
+            crossExactLocales.add(candidate);
+    }
+    if (primaryLocale && primaryLocale !== targetLocale) {
+        crossExactLocales.add(primaryLocale);
+    }
+    const crossLanguageCodes = new Set();
+    for (const locale of crossExactLocales) {
+        const language = localeLanguage(locale);
+        if (language)
+            crossLanguageCodes.add(language);
+    }
+    return { primaryLocale, targetLocale, crossExactLocales, crossLanguageCodes };
+}
+export function resolveCrossLocalizationTier(args) {
+    const keywordLocale = normalizeAscLocale(args.keywordLocale);
+    const includeCrossLocalization = args.includeCrossLocalization !== false;
+    const { primaryLocale, targetLocale, crossExactLocales, crossLanguageCodes } = resolveCrossLocalizedLocales({
+        targetLocale: args.targetLocale,
+        primaryLocale: args.primaryLocale,
+    });
+    if (!keywordLocale || !targetLocale)
+        return null;
+    if (keywordLocale === targetLocale)
+        return 'target_exact';
+    const keywordLanguage = localeLanguage(keywordLocale);
+    if (!keywordLanguage)
+        return null;
+    if (!includeCrossLocalization) {
+        if (isLanguageOnly(keywordLocale) && keywordLanguage === localeLanguage(targetLocale)) {
+            return 'target_language';
+        }
+        return null;
+    }
+    if (primaryLocale && keywordLocale === primaryLocale)
+        return 'primary_exact';
+    if (primaryLocale && isLanguageOnly(keywordLocale) && keywordLanguage === localeLanguage(primaryLocale)) {
+        return 'primary_language';
+    }
+    if (isLanguageOnly(keywordLocale) && keywordLanguage === localeLanguage(targetLocale)) {
+        return 'target_language';
+    }
+    if (crossExactLocales.has(keywordLocale))
+        return 'cross_exact';
+    if (isLanguageOnly(keywordLocale) && crossLanguageCodes.has(keywordLanguage)) {
+        return 'cross_language';
+    }
+    return null;
+}
+export function selectCrossLocalizedRows(rows, args) {
+    if (!rows?.length)
+        return [];
+    const selected = [];
+    for (const row of rows) {
+        const tier = resolveCrossLocalizationTier({
+            keywordLocale: row.locale,
+            targetLocale: args.targetLocale,
+            primaryLocale: args.primaryLocale,
+            includeCrossLocalization: args.includeCrossLocalization,
+        });
+        if (!tier)
+            continue;
+        selected.push({
+            row,
+            tier,
+            weight: CROSS_LOCALIZATION_TIER_WEIGHT[tier],
+        });
+    }
+    selected.sort((left, right) => right.weight - left.weight);
+    return selected;
+}

package/packages/asc-shared/dist/dedupe.d.ts

@@ -0,0 +1,17 @@
+export type KeywordField = "title" | "subtitle" | "keywords";
+export type DuplicateEntry = {
+    keyword: string;
+    fields: KeywordField[];
+};
+export declare const DEFAULT_IGNORED_DUPLICATE_KEYWORDS: readonly ["a", "an", "and", "or", "the", "to", "for", "of", "in", "on", "with", "der", "die", "das", "und", "mit", "fur", "fuer", "de", "la", "le", "les", "et", "el", "los", "las", "y", "en", "para", "con", "por", "il", "lo", "gli", "e", "di", "per", "com"];
+export declare function normalizeKeywordToken(value: string): string;
+export declare function tokenizeText(value: string): string[];
+export declare function tokenizeKeywordField(value: string): string[];
+export declare function findDuplicateKeywords(fields: {
+    title?: string;
+    subtitle?: string;
+    keywords?: string;
+}, options?: {
+    ignoreKeywords?: Iterable<string>;
+}): DuplicateEntry[];
+//# sourceMappingURL=dedupe.d.ts.map