pxt-core 9.3.16 → 9.3.19

package/built/cli.js

@@ -335,7 +335,7 @@ function checkIfTaggedCommitAsync() {
     });
 }
 let readJson = nodeutil.readJson;
-function ciAsync() {
+async function ciAsync() {
     forceCloudBuild = true;
     const buildInfo = ciBuildInfo();
     pxt.log(`ci build using ${buildInfo.ci}`);
@@ -381,56 +381,55 @@ function ciAsync() {
     let pkg = readJson("package.json");
     if (pkg["name"] == "pxt-core") {
         pxt.log("pxt-core build");
-        return checkIfTaggedCommitAsync()
-            .then(isTaggedCommit => {
-            pxt.log(`is tagged commit: ${isTaggedCommit}`);
-            let p = npmPublishAsync();
-            if (branch === "master" && isTaggedCommit) {
-                if (uploadDocs)
-                    p = p
-                        .then(() => buildWebStringsAsync())
-                        .then(() => crowdin.execCrowdinAsync("upload", "built/webstrings.json"))
-                        .then(() => crowdin.execCrowdinAsync("upload", "built/skillmap-strings.json"))
-                        .then(() => crowdin.execCrowdinAsync("upload", "built/authcode-strings.json"))
-                        .then(() => crowdin.execCrowdinAsync("upload", "built/multiplayer-strings.json"))
-                        .then(() => crowdin.execCrowdinAsync("upload", "built/kiosk-strings.json"))
-                        .then(() => crowdin.execCrowdinAsync("upload", "built/teachertool-strings.json"));
-                if (uploadApiStrings)
-                    p = p.then(() => crowdin.execCrowdinAsync("upload", "built/strings.json"));
-                if (uploadDocs || uploadApiStrings)
-                    p = p.then(() => crowdin.internalUploadTargetTranslationsAsync(uploadApiStrings, uploadDocs));
+        const isTaggedCommit = await checkIfTaggedCommitAsync();
+        pxt.log(`is tagged commit: ${isTaggedCommit}`);
+        await npmPublishAsync();
+        if (branch === "master" && isTaggedCommit) {
+            if (uploadDocs) {
+                await buildWebStringsAsync();
+                await crowdin.uploadBuiltStringsAsync("built/webstrings.json");
+                await crowdin.uploadBuiltStringsAsync(`built/skillmap-strings.json`);
+                await crowdin.uploadBuiltStringsAsync(`built/authcode-strings.json`);
+                await crowdin.uploadBuiltStringsAsync(`built/multiplayer-strings.json`);
+                await crowdin.uploadBuiltStringsAsync(`built/kiosk-strings.json`);
+                await crowdin.uploadBuiltStringsAsync(`built/teachertool-strings.json`);
+            }
+            if (uploadApiStrings) {
+                await crowdin.uploadBuiltStringsAsync("built/strings.json");
             }
-            return p;
-        });
+            if (uploadDocs || uploadApiStrings) {
+                await crowdin.internalUploadTargetTranslationsAsync(uploadApiStrings, uploadDocs);
+                pxt.log("translations uploaded");
+            }
+            else {
+                pxt.log("skipping translations upload");
+            }
+        }
     }
     else {
         pxt.log("target build");
-        return internalBuildTargetAsync()
-            .then(() => internalCheckDocsAsync(true))
-            .then(() => blockTestsAsync())
-            .then(() => npmPublishAsync())
-            .then(() => {
-            if (!process.env["PXT_ACCESS_TOKEN"]) {
-                // pull request, don't try to upload target
-                pxt.log('no token, skipping upload');
-                return Promise.resolve();
-            }
+        await internalBuildTargetAsync();
+        await internalCheckDocsAsync(true);
+        await blockTestsAsync();
+        await npmPublishAsync();
+        if (!process.env["PXT_ACCESS_TOKEN"]) {
+            // pull request, don't try to upload target
+            pxt.log('no token, skipping upload');
+        }
+        else {
             const trg = readLocalPxTarget();
             const label = `${trg.id}/${tag || latest}`;
             pxt.log(`uploading target with label ${label}...`);
-            return uploadTargetAsync(label);
-        })
-            .then(() => {
-            pxt.log("target uploaded");
-            if (uploadDocs || uploadApiStrings) {
-                return crowdin.internalUploadTargetTranslationsAsync(uploadApiStrings, uploadDocs)
-                    .then(() => pxt.log("translations uploaded"));
-            }
-            else {
-                pxt.log("skipping translations upload");
-                return Promise.resolve();
-            }
-        });
+            await uploadTargetAsync(label);
+        }
+        pxt.log("target uploaded");
+        if (uploadDocs || uploadApiStrings) {
+            await crowdin.internalUploadTargetTranslationsAsync(uploadApiStrings, uploadDocs);
+            pxt.log("translations uploaded");
+        }
+        else {
+            pxt.log("skipping translations upload");
+        }
     }
 }
 function lintJSONInDirectory(dir) {
@@ -6311,7 +6310,7 @@ ${pxt.crowdin.KEY_VARIABLE} - crowdin key
         advanced: true,
     }, pc => uploadTargetRefsAsync(pc.args[0]));
     advancedCommand("uploadtt", "upload tagged release", uploadTaggedTargetAsync, "");
-    advancedCommand("downloadtrgtranslations", "download translations from bundled projects", crowdin.downloadTargetTranslationsAsync, "<package>");
+    advancedCommand("downloadtrgtranslations", "download translations from bundled projects", crowdin.downloadTargetTranslationsAsync, "[package]");
     p.defineCommand({
         name: "checkdocs",
         onlineHelp: true,

package/built/crowdin.d.ts

@@ -2,6 +2,7 @@ import Map = pxt.Map;
 import * as commandParser from './commandparser';
 export declare function uploadTargetTranslationsAsync(parsed?: commandParser.ParsedCommand): Promise<void>;
 export declare function internalUploadTargetTranslationsAsync(uploadApiStrings: boolean, uploadDocs: boolean): Promise<void>;
+export declare function uploadBuiltStringsAsync(filename: string, crowdinDir?: string): Promise<void>;
 export declare function downloadTargetTranslationsAsync(parsed?: commandParser.ParsedCommand): Promise<void>;
-export declare function buildAllTranslationsAsync(langToStringsHandlerAsync: (fileName: string) => Promise<Map<Map<string>>>, singleDir?: string): Promise<void>;
+export declare function buildAllTranslationsAsync(fetchFileTranslationAsync: (fileName: string) => Promise<Map<Map<string>>>, singleDir?: string): Promise<void>;
 export declare function execCrowdinAsync(cmd: string, ...args: string[]): Promise<void>;

package/built/crowdin.js

@@ -1,107 +1,78 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.execCrowdinAsync = exports.buildAllTranslationsAsync = exports.downloadTargetTranslationsAsync = exports.internalUploadTargetTranslationsAsync = exports.uploadTargetTranslationsAsync = void 0;
+exports.execCrowdinAsync = exports.buildAllTranslationsAsync = exports.downloadTargetTranslationsAsync = exports.uploadBuiltStringsAsync = exports.internalUploadTargetTranslationsAsync = exports.uploadTargetTranslationsAsync = void 0;
 const nodeutil = require("./nodeutil");
 const fs = require("fs");
 const path = require("path");
-function crowdinCredentialsAsync() {
-    const prj = pxt.appTarget.appTheme.crowdinProject;
-    const branch = pxt.appTarget.appTheme.crowdinBranch;
-    if (!prj) {
-        pxt.log(`crowdin upload skipped, Crowdin project missing in target theme`);
-        return Promise.resolve(undefined);
-    }
-    let key;
-    if (pxt.crowdin.testMode)
-        key = pxt.crowdin.TEST_KEY;
-    else
-        key = process.env[pxt.crowdin.KEY_VARIABLE];
-    if (!key) {
-        pxt.log(`Crowdin operation skipped: '${pxt.crowdin.KEY_VARIABLE}' variable is missing`);
-        return Promise.resolve(undefined);
-    }
-    return Promise.resolve({ prj, key, branch });
-}
+const crowdinApi_1 = require("./crowdinApi");
 function uploadTargetTranslationsAsync(parsed) {
     const uploadDocs = parsed && !!parsed.flags["docs"];
     const uploadApiStrings = parsed && !!parsed.flags["apis"];
-    if (parsed && !!parsed.flags["test"])
+    if (parsed && !!parsed.flags["test"]) {
         pxt.crowdin.setTestMode();
+    }
     return internalUploadTargetTranslationsAsync(uploadApiStrings, uploadDocs);
 }
 exports.uploadTargetTranslationsAsync = uploadTargetTranslationsAsync;
-function internalUploadTargetTranslationsAsync(uploadApiStrings, uploadDocs) {
+async function internalUploadTargetTranslationsAsync(uploadApiStrings, uploadDocs) {
     pxt.log(`uploading translations (apis ${uploadApiStrings ? "yes" : "no"}, docs ${uploadDocs ? "yes" : "no"})...`);
-    return crowdinCredentialsAsync()
-        .then(cred => {
-        if (!cred)
-            return Promise.resolve();
-        pxt.log("got Crowdin credentials");
-        const crowdinDir = pxt.appTarget.id;
-        if (crowdinDir == "core") {
-            if (!uploadDocs) {
-                pxt.log('missing --docs flag, skipping');
-                return Promise.resolve();
+    const crowdinDir = pxt.appTarget.id;
+    if (crowdinDir == "core") {
+        if (!uploadDocs) {
+            pxt.log('missing --docs flag, skipping');
+            return;
+        }
+        await uploadDocsTranslationsAsync("docs", crowdinDir);
+        await uploadDocsTranslationsAsync("common-docs", crowdinDir);
+    }
+    else {
+        if (uploadApiStrings) {
+            await uploadBuiltStringsAsync("built/target-strings.json", crowdinDir);
+            if (fs.existsSync("built/sim-strings.json")) {
+                await uploadBuiltStringsAsync("built/sim-strings.json", crowdinDir);
             }
-            return uploadDocsTranslationsAsync("docs", crowdinDir, cred.branch, cred.prj, cred.key)
-                .then(() => uploadDocsTranslationsAsync("common-docs", crowdinDir, cred.branch, cred.prj, cred.key));
+            await uploadBundledTranslationsAsync(crowdinDir);
         }
         else {
-            let p = Promise.resolve();
-            if (uploadApiStrings)
-                p = p.then(() => execCrowdinAsync("upload", "built/target-strings.json", crowdinDir))
-                    .then(() => fs.existsSync("built/sim-strings.json") ? execCrowdinAsync("upload", "built/sim-strings.json", crowdinDir) : Promise.resolve())
-                    .then(() => uploadBundledTranslationsAsync(crowdinDir, cred.branch, cred.prj, cred.key));
-            else
-                p = p.then(() => pxt.log(`translations: skipping api strings upload`));
-            if (uploadDocs)
-                p = p.then(() => uploadDocsTranslationsAsync("docs", crowdinDir, cred.branch, cred.prj, cred.key))
-                    // scan for docs in bundled packages
-                    .then(() => Promise.all(pxt.appTarget.bundleddirs
-                    // there must be a folder under .../docs
-                    .filter(pkgDir => nodeutil.existsDirSync(path.join(pkgDir, "docs")))
-                    // upload to crowdin
-                    .map(pkgDir => uploadDocsTranslationsAsync(path.join(pkgDir, "docs"), crowdinDir, cred.branch, cred.prj, cred.key))).then(() => {
-                    pxt.log("docs uploaded");
-                }));
-            else
-                p = p.then(() => pxt.log(`translations: skipping docs upload`));
-            return p;
+            pxt.log(`translations: skipping api strings upload`);
         }
-    });
+        if (uploadDocs) {
+            await uploadDocsTranslationsAsync("docs", crowdinDir);
+            await Promise.all(pxt.appTarget.bundleddirs
+                .filter(pkgDir => nodeutil.existsDirSync(path.join(pkgDir, "docs")))
+                .map(pkgDir => uploadDocsTranslationsAsync(path.join(pkgDir, "docs"), crowdinDir)));
+            pxt.log("docs uploaded");
+        }
+        else {
+            pxt.log(`translations: skipping docs upload`);
+        }
+    }
 }
 exports.internalUploadTargetTranslationsAsync = internalUploadTargetTranslationsAsync;
-function uploadDocsTranslationsAsync(srcDir, crowdinDir, branch, prj, key) {
-    pxt.log(`uploading from ${srcDir} to ${crowdinDir} under project ${prj}/${branch || ""}`);
+async function uploadBuiltStringsAsync(filename, crowdinDir) {
+    const baseName = path.basename(filename);
+    const crowdinFile = crowdinDir ? path.join(crowdinDir, baseName) : baseName;
+    const contents = fs.readFileSync(filename, "utf8");
+    pxt.log(`Uploading ${filename} to ${crowdinFile}`);
+    await (0, crowdinApi_1.uploadFileAsync)(crowdinFile, contents);
+}
+exports.uploadBuiltStringsAsync = uploadBuiltStringsAsync;
+async function uploadDocsTranslationsAsync(srcDir, crowdinDir) {
+    pxt.log(`Uploading from ${srcDir} to ${crowdinDir}`);
     const ignoredDirectoriesList = getIgnoredDirectories(srcDir);
     const todo = nodeutil.allFiles(srcDir).filter(f => /\.md$/.test(f) && !/_locales/.test(f)).reverse();
-    const knownFolders = {};
-    const ensureFolderAsync = (crowdd) => {
-        if (!knownFolders[crowdd]) {
-            knownFolders[crowdd] = true;
-            pxt.log(`creating folder ${crowdd}`);
-            return pxt.crowdin.createDirectoryAsync(branch, prj, key, crowdd);
-        }
-        return Promise.resolve();
-    };
-    const nextFileAsync = (f) => {
-        if (!f)
-            return Promise.resolve();
-        const crowdf = path.join(crowdinDir, f);
-        const crowdd = path.dirname(crowdf);
+    for (const file of todo) {
+        if (!file)
+            continue;
+        const crowdinFile = path.join(crowdinDir, file);
         // check if file should be ignored
-        if (ignoredDirectoriesList.filter(d => path.dirname(f).indexOf(d) == 0).length > 0) {
-            pxt.log(`skipping ${f} because of .crowdinignore file`);
-            return nextFileAsync(todo.pop());
+        if (ignoredDirectoriesList.filter(d => path.dirname(file).indexOf(d) == 0).length > 0) {
+            pxt.log(`skipping ${file} because of .crowdinignore file`);
+            continue;
         }
-        const data = fs.readFileSync(f, 'utf8');
-        pxt.log(`uploading ${f} to ${crowdf}`);
-        return ensureFolderAsync(crowdd)
-            .then(() => pxt.crowdin.uploadTranslationAsync(branch, prj, key, crowdf, data))
-            .then(() => nextFileAsync(todo.pop()));
-    };
-    return ensureFolderAsync(path.join(crowdinDir, srcDir))
-        .then(() => nextFileAsync(todo.pop()));
+        pxt.log(`Uploading ${file} to ${crowdinFile}`);
+        await (0, crowdinApi_1.uploadFileAsync)(crowdinFile, fs.readFileSync(file, "utf8"));
+    }
 }
 function getIgnoredDirectories(srcDir) {
     const ignoredDirectories = {};
@@ -117,40 +88,39 @@ function getIgnoredDirectories(srcDir) {
     });
     return Object.keys(ignoredDirectories).filter(d => ignoredDirectories[d]);
 }
-function uploadBundledTranslationsAsync(crowdinDir, branch, prj, key) {
+async function uploadBundledTranslationsAsync(crowdinDir) {
     const todo = [];
-    pxt.appTarget.bundleddirs.forEach(dir => {
+    for (const dir of pxt.appTarget.bundleddirs) {
         const locdir = path.join(dir, "_locales");
-        if (fs.existsSync(locdir))
-            fs.readdirSync(locdir)
-                .filter(f => /strings\.json$/i.test(f))
-                .forEach(f => todo.push(path.join(locdir, f)));
-    });
+        if (fs.existsSync(locdir)) {
+            const stringsFiles = fs.readdirSync(locdir).filter(f => /strings\.json$/i.test(f));
+            for (const file of stringsFiles) {
+                todo.unshift(path.join(locdir, file));
+            }
+        }
+    }
     pxt.log(`uploading bundled translations to Crowdin (${todo.length} files)`);
-    const nextFileAsync = () => {
-        const f = todo.pop();
-        if (!f)
-            return Promise.resolve();
-        const data = JSON.parse(fs.readFileSync(f, 'utf8'));
-        const crowdf = path.join(crowdinDir, path.basename(f));
-        pxt.log(`uploading ${f} to ${crowdf}`);
-        return pxt.crowdin.uploadTranslationAsync(branch, prj, key, crowdf, JSON.stringify(data))
-            .then(nextFileAsync);
-    };
-    return nextFileAsync();
+    for (const file of todo) {
+        const data = JSON.parse(fs.readFileSync(file, 'utf8'));
+        const crowdinFile = path.join(crowdinDir, path.basename(file));
+        pxt.log(`Uploading ${file} to ${crowdinFile}`);
+        await (0, crowdinApi_1.uploadFileAsync)(crowdinFile, JSON.stringify(data));
+    }
 }
 async function downloadTargetTranslationsAsync(parsed) {
     const name = parsed === null || parsed === void 0 ? void 0 : parsed.args[0];
-    const cred = await crowdinCredentialsAsync();
-    if (!cred)
-        return;
     await buildAllTranslationsAsync(async (fileName) => {
         pxt.log(`downloading ${fileName}`);
-        return pxt.crowdin.downloadTranslationsAsync(cred.branch, cred.prj, cred.key, fileName, { translatedOnly: true, validatedOnly: true });
+        const translations = await (0, crowdinApi_1.downloadFileTranslationsAsync)(fileName);
+        const parsed = {};
+        for (const file of Object.keys(translations)) {
+            parsed[file] = JSON.parse(translations[file]);
+        }
+        return parsed;
     }, name);
 }
 exports.downloadTargetTranslationsAsync = downloadTargetTranslationsAsync;
-async function buildAllTranslationsAsync(langToStringsHandlerAsync, singleDir) {
+async function buildAllTranslationsAsync(fetchFileTranslationAsync, singleDir) {
     await buildTranslationFilesAsync(["sim-strings.json"], "sim-strings.json");
     await buildTranslationFilesAsync(["target-strings.json"], "target-strings.json");
     await buildTranslationFilesAsync(["strings.json"], "strings.json", true);
@@ -176,7 +146,7 @@ async function buildAllTranslationsAsync(langToStringsHandlerAsync, singleDir) {
             const locdir = path.dirname(filePath);
             const projectdir = path.dirname(locdir);
             pxt.debug(`projectdir: ${projectdir}`);
-            const data = await langToStringsHandlerAsync(crowdf);
+            const data = await fetchFileTranslationAsync(crowdf);
             for (const lang of Object.keys(data)) {
                 const dataLang = data[lang];
                 if (!dataLang || !stringifyTranslations(dataLang))
@@ -212,120 +182,125 @@ function stringifyTranslations(strings) {
     else
         return JSON.stringify(trg, null, 2);
 }
-function execCrowdinAsync(cmd, ...args) {
+async function execCrowdinAsync(cmd, ...args) {
     pxt.log(`executing Crowdin command ${cmd}...`);
-    const prj = pxt.appTarget.appTheme.crowdinProject;
-    if (!prj) {
-        console.log(`crowdin operation skipped, crowdin project not specified in pxtarget.json`);
-        return Promise.resolve();
-    }
-    const branch = pxt.appTarget.appTheme.crowdinBranch;
-    return crowdinCredentialsAsync()
-        .then(crowdinCredentials => {
-        if (!crowdinCredentials)
-            return Promise.resolve();
-        const key = crowdinCredentials.key;
-        cmd = cmd.toLowerCase();
-        if (!args[0] && (cmd != "clean" && cmd != "stats"))
-            throw new Error(cmd == "status" ? "language missing" : "filename missing");
-        switch (cmd) {
-            case "stats": return statsCrowdinAsync(prj, key, args[0]);
-            case "clean": return cleanCrowdinAsync(prj, key, args[0] || "docs");
-            case "upload": return uploadCrowdinAsync(branch, prj, key, args[0], args[1]);
-            case "download": {
-                if (!args[1])
-                    throw new Error("output path missing");
-                const fn = path.basename(args[0]);
-                return pxt.crowdin.downloadTranslationsAsync(branch, prj, key, args[0], { translatedOnly: true, validatedOnly: true })
-                    .then(r => {
-                    Object.keys(r).forEach(k => {
-                        const rtranslations = stringifyTranslations(r[k]);
-                        if (!rtranslations)
-                            return;
-                        nodeutil.mkdirP(path.join(args[1], k));
-                        const outf = path.join(args[1], k, fn);
-                        console.log(`writing ${outf}`);
-                        nodeutil.writeFileSync(outf, rtranslations, { encoding: "utf8" });
-                    });
-                });
+    switch (cmd.toLowerCase()) {
+        case "stats":
+            execStatsAsync(args[0]);
+            break;
+        case "clean":
+            await execCleanAsync(args[0] || "docs");
+            break;
+        case "upload":
+            if (!args[0]) {
+                throw new Error("filename missing");
             }
-            default: throw new Error("unknown command");
-        }
-    });
+            await uploadBuiltStringsAsync(args[0], args[1]);
+            break;
+        case "download":
+            if (!args[1]) {
+                throw new Error("output path missing");
+            }
+            await execDownloadAsync(args[0], args[1]);
+            break;
+        default:
+            throw new Error("unknown command");
+    }
 }
 exports.execCrowdinAsync = execCrowdinAsync;
-function cleanCrowdinAsync(prj, key, dir) {
-    const p = pxt.appTarget.id + "/" + dir;
-    return pxt.crowdin.listFilesAsync(prj, key, p)
-        .then(files => {
-        files.filter(f => !nodeutil.fileExistsSync(f.fullName.substring(pxt.appTarget.id.length + 1)))
-            .forEach(f => pxt.log(`crowdin: dead file: ${f.branch ? f.branch + "/" : ""}${f.fullName}`));
-    });
+async function execDownloadAsync(filename, outputDir) {
+    const basename = path.basename(filename);
+    pxt.log("Downloading translations");
+    const translations = await (0, crowdinApi_1.downloadFileTranslationsAsync)(filename);
+    for (const language of Object.keys(translations)) {
+        const langTranslations = stringifyTranslations(JSON.parse(translations[language]));
+        if (!langTranslations)
+            continue;
+        nodeutil.mkdirP(path.join(outputDir, language));
+        const outFilename = path.join(outputDir, language, basename);
+        console.log(`Writing ${outFilename}`);
+        nodeutil.writeFileSync(outFilename, langTranslations, { encoding: "utf8" });
+    }
 }
-function statsCrowdinAsync(prj, key, preferredLang) {
-    pxt.log(`collecting crowdin stats for ${prj} ${preferredLang ? `for language ${preferredLang}` : `all languages`}`);
-    console.log(`context\t language\t translated%\t approved%\t phrases\t translated\t approved`);
-    const fn = `crowdinstats.csv`;
-    let headers = 'sep=\t\r\n';
-    headers += `id\t file\t language\t phrases\t translated\t approved\r\n`;
-    nodeutil.writeFileSync(fn, headers, { encoding: "utf8" });
-    return pxt.crowdin.projectInfoAsync(prj, key)
-        .then(info => {
-        if (!info)
-            throw new Error("info failed");
-        let languages = info.languages;
-        // remove in-context language
-        languages = languages.filter(l => l.code != ts.pxtc.Util.TRANSLATION_LOCALE);
-        if (preferredLang)
-            languages = languages.filter(lang => lang.code.toLowerCase() == preferredLang.toLowerCase());
-        return Promise.all(languages.map(lang => langStatsCrowdinAsync(prj, key, lang.code)));
-    }).then(() => {
-        console.log(`stats written to ${fn}`);
-    });
-    function langStatsCrowdinAsync(prj, key, lang) {
-        return pxt.crowdin.languageStatsAsync(prj, key, lang)
-            .then(stats => {
-            let uiphrases = 0;
-            let uitranslated = 0;
-            let uiapproved = 0;
-            let corephrases = 0;
-            let coretranslated = 0;
-            let coreapproved = 0;
-            let phrases = 0;
-            let translated = 0;
-            let approved = 0;
-            let r = '';
-            stats.forEach(stat => {
-                const cfn = `${stat.branch ? stat.branch + "/" : ""}${stat.fullName}`;
-                r += `${stat.id}\t ${cfn}\t ${lang}\t ${stat.phrases}\t ${stat.translated}\t ${stat.approved}\r\n`;
-                if (stat.fullName == "strings.json") {
-                    uiapproved += Number(stat.approved);
-                    uitranslated += Number(stat.translated);
-                    uiphrases += Number(stat.phrases);
-                }
-                else if (/core-strings\.json$/.test(stat.fullName)) {
-                    coreapproved += Number(stat.approved);
-                    coretranslated += Number(stat.translated);
-                    corephrases += Number(stat.phrases);
-                }
-                else if (/-strings\.json$/.test(stat.fullName)) {
-                    approved += Number(stat.approved);
-                    translated += Number(stat.translated);
-                    phrases += Number(stat.phrases);
-                }
-            });
-            fs.appendFileSync(fn, r, { encoding: "utf8" });
-            console.log(`ui\t ${lang}\t ${(uitranslated / uiphrases * 100) >> 0}%\t ${(uiapproved / uiphrases * 100) >> 0}%\t ${uiphrases}\t ${uitranslated}\t ${uiapproved}`);
-            console.log(`core\t ${lang}\t ${(coretranslated / corephrases * 100) >> 0}%\t ${(coreapproved / corephrases * 100) >> 0}%\t ${corephrases}\t ${coretranslated}\t ${coreapproved}`);
-            console.log(`blocks\t ${lang}\t ${(translated / phrases * 100) >> 0}%\t ${(approved / phrases * 100) >> 0}%\t ${phrases}\t ${translated}\t ${approved}`);
-        });
+async function execCleanAsync(dir) {
+    const directoryPath = pxt.appTarget.id + "/" + dir;
+    const files = await (0, crowdinApi_1.listFilesAsync)(directoryPath);
+    for (const file of files) {
+        if (!nodeutil.fileExistsSync(file.substring(pxt.appTarget.id.length + 1))) {
+            pxt.log(`crowdin: dead file: ${file}`);
+        }
     }
 }
-function uploadCrowdinAsync(branch, prj, key, p, dir) {
-    let fn = path.basename(p);
-    if (dir)
-        fn = dir.replace(/[\\/]*$/g, '') + '/' + fn;
-    const data = JSON.parse(fs.readFileSync(p, "utf8"));
-    pxt.log(`upload ${fn} (${Object.keys(data).length} strings) to https://crowdin.com/project/${prj}${branch ? `?branch=${branch}` : ''}`);
-    return pxt.crowdin.uploadTranslationAsync(branch, prj, key, fn, JSON.stringify(data));
+async function execStatsAsync(language) {
+    const crowdinDir = pxt.appTarget.id;
+    // If this is run inside pxt-core, give results for all targets
+    const isCore = crowdinDir === "core";
+    pxt.log(`collecting crowdin stats for ${isCore ? "all targets" : crowdinDir} ${language ? `for language ${language}` : `all languages`}`);
+    const files = await (0, crowdinApi_1.listFilesAsync)();
+    const stats = {};
+    const outputCsvFile = `crowdinstats.csv`;
+    let headers = 'sep=\t\r\n';
+    headers += `file\t language\t phrases\t translated\t approved\r\n`;
+    nodeutil.writeFileSync(outputCsvFile, headers, { encoding: "utf8" });
+    for (const file of files) {
+        pxt.debug("Processing file: " + file + "...");
+        // We only care about strings files
+        if (!file.endsWith("-strings.json"))
+            continue;
+        // Files for core are in the top-level of the crowdin project
+        const isCoreFile = file.indexOf("/") === -1;
+        // Only include files for the current target and core
+        if (!isCore && !isCoreFile && !file.startsWith(crowdinDir + "/"))
+            continue;
+        pxt.debug(`Downloading progress`);
+        const progress = await (0, crowdinApi_1.getFileProgressAsync)(file, language && [language]);
+        let fileCsvRows = "";
+        for (const language of progress) {
+            if (!stats[language.languageId]) {
+                stats[language.languageId] = {
+                    uiphrases: 0,
+                    uitranslated: 0,
+                    uiapproved: 0,
+                    corephrases: 0,
+                    coretranslated: 0,
+                    coreapproved: 0,
+                    phrases: 0,
+                    translated: 0,
+                    approved: 0
+                };
+            }
+            const fileCsvColumns = [
+                file,
+                language.languageId,
+                language.phrases.total,
+                language.phrases.translated,
+                language.phrases.approved
+            ];
+            fileCsvRows += `${fileCsvColumns.join("\t ")}\r\n`;
+            const langStats = stats[language.languageId];
+            if (file === "strings.json") {
+                langStats.uiapproved += language.phrases.approved;
+                langStats.uitranslated += language.phrases.translated;
+                langStats.uiphrases += language.phrases.total;
+            }
+            else if (/core-strings\.json$/.test(file)) {
+                langStats.coreapproved += language.phrases.approved;
+                langStats.coretranslated += language.phrases.translated;
+                langStats.corephrases += language.phrases.total;
+            }
+            else {
+                langStats.approved += language.phrases.approved;
+                langStats.translated += language.phrases.translated;
+                langStats.phrases += language.phrases.total;
+            }
+        }
+        fs.appendFileSync(outputCsvFile, fileCsvRows, { encoding: "utf8" });
+    }
+    console.log(`context\t language\t translated%\t approved%\t phrases\t translated\t approved`);
+    for (const language of Object.keys(stats)) {
+        const { uiphrases, uitranslated, uiapproved, corephrases, coretranslated, coreapproved, phrases, translated, approved, } = stats[language];
+        console.log(`ui\t ${language}\t ${(uitranslated / uiphrases * 100) >> 0}%\t ${(uiapproved / uiphrases * 100) >> 0}%\t ${uiphrases}\t ${uitranslated}\t ${uiapproved}`);
+        console.log(`core\t ${language}\t ${(coretranslated / corephrases * 100) >> 0}%\t ${(coreapproved / corephrases * 100) >> 0}%\t ${corephrases}\t ${coretranslated}\t ${coreapproved}`);
+        console.log(`blocks\t ${language}\t ${(translated / phrases * 100) >> 0}%\t ${(approved / phrases * 100) >> 0}%\t ${phrases}\t ${translated}\t ${approved}`);
+    }
 }

package/built/crowdinApi.d.ts

@@ -0,0 +1,9 @@
+export declare function setProjectId(id: number): void;
+export declare function uploadFileAsync(fileName: string, fileContent: string): Promise<void>;
+export declare function getProjectInfoAsync(): Promise<import("@crowdin/crowdin-api-client").ProjectsGroupsModel.Project | import("@crowdin/crowdin-api-client").ProjectsGroupsModel.ProjectSettings>;
+export declare function getProjectProgressAsync(languages?: string[]): Promise<import("@crowdin/crowdin-api-client").TranslationStatusModel.LanguageProgress[]>;
+export declare function getDirectoryProgressAsync(directory: string, languages?: string[]): Promise<import("@crowdin/crowdin-api-client").TranslationStatusModel.LanguageProgress[]>;
+export declare function getFileProgressAsync(file: string, languages?: string[]): Promise<import("@crowdin/crowdin-api-client").TranslationStatusModel.LanguageProgress[]>;
+export declare function listFilesAsync(directory?: string): Promise<string[]>;
+export declare function downloadTranslationsAsync(directory?: string): Promise<pxt.Map<string>>;
+export declare function downloadFileTranslationsAsync(fileName: string): Promise<pxt.Map<string>>;