@pi-r/android 0.7.3 → 0.8.1

package/extensions/app/manifest/index.js

@@ -4,18 +4,18 @@ const htmlparser2 = require("htmlparser2");
 const domhandler = require("domhandler");
 const domutils = require("domutils");
 const domserializer = require("dom-serializer");
-const util_1 = require("@e-mc/document/util");
 const types_1 = require("@e-mc/types");
+const util_1 = require("@e-mc/document/util");
 const Parser = htmlparser2.Parser;
 const DomHandler = domhandler.DomHandler;
 const MANIFEST_ATTR = ['package', 'android:sharedUserId', 'android:sharedUserLabel', 'android:sharedUserMaxSdkVersion', 'android:versionCode', 'android:versionName', 'android:installLocation'];
-module.exports = function finalize(instance) {
+function finalize(instance) {
     const config = instance.config;
     const manifest = config.manifest;
     if (!manifest) {
         return;
     }
-    let { localUri, source, existing } = instance.findTemplate(path.join(this.baseDirectory, config.mainParentDir, config.mainSrcDir), "AndroidManifest.xml", { detect: this.incremental !== 'staging' });
+    let { localUri, source, existing } = instance.findTemplate(path.join(this.baseDirectory, config.mainParentDir, config.mainSrcDir), "AndroidManifest.xml", { detect: instance.detect(this) });
     if (localUri && source && instance.canWrite(localUri, { ownPermissionOnly: true })) {
         const { supportsRtl, label, theme, activity, metaData = [], activityName, fontProvider } = manifest.application || {};
         const profileable = config.profileable;
@@ -28,7 +28,7 @@ module.exports = function finalize(instance) {
                     case 'label':
                         return '@string/' + (label || 'app_name');
                     case 'theme':
-                        return '@style/' + (theme || 'Theme.Android2');
+                        return '@style/' + (theme || 'Theme.Android4');
                     case 'activityName':
                         return activityName || '';
                     case 'profileable':
@@ -65,7 +65,7 @@ module.exports = function finalize(instance) {
                     if (activityName) {
                         for (const item of activities) {
                             const intentFilter = domutils.findAll(elem => elem.tagName === 'intent-filter', [item]);
-                            if (intentFilter.length) {
+                            if (intentFilter.length > 0) {
                                 const action = domutils.findOne(elem => elem.tagName === 'action' && elem.attribs['android:name'] === 'android.intent.action.MAIN', intentFilter);
                                 if (action) {
                                     const attribs = item.attribs;
@@ -131,14 +131,14 @@ module.exports = function finalize(instance) {
             metaData.push({ name: 'preloaded_fonts', resource: '@array/' + fontProvider });
         }
         const keys = Object.keys(manifest).map(attr => MANIFEST_ATTR.includes(attr) ? attr : attr !== 'package' && MANIFEST_ATTR.includes('android:' + attr) ? attr : '').filter(item => item);
-        if (keys.length || (0, types_1.isArray)(metaData)) {
+        if (keys.length > 0 || (0, types_1.isArray)(metaData)) {
             new Parser(new DomHandler((err, dom) => {
                 if (err) {
                     instance.writeFail(['Unable to parse XML document', "AndroidManifest.xml"], err, 0);
                     return;
                 }
                 let target = null;
-                if (keys.length && (target = domutils.findOne(elem => elem.tagName === 'manifest', dom, true))) {
+                if (keys.length > 0 && (target = domutils.findOne(elem => elem.tagName === 'manifest', dom, true))) {
                     for (let key of keys) {
                         if (!key.startsWith('android:') && key !== 'package') {
                             key = 'android:' + key;
@@ -182,4 +182,5 @@ module.exports = function finalize(instance) {
             }
         }
     }
-};
+}
+module.exports = finalize;

package/extensions/gradle/dependencies/index.js

@@ -1,14 +1,20 @@
 "use strict";
 const path = require("path");
-const util_1 = require("@e-mc/document/util");
-const types_1 = require("@e-mc/types");
+const fs = require("fs");
 const Document = require("@e-mc/document");
+const types_1 = require("@e-mc/types");
+const util_1 = require("@e-mc/document/util");
 const REGEXP_SEMVER = /^((\s*,\s*)?[([\]]((\s*,\s*)?\d+\.\d+(\s*,\s*)?)+[)\][])+$/;
+const REGEXP_DEPENDENCIES = /dependencies\s+\{((?:{[^{]*{|{[^}]*}|}[^}]*}|\\}*?|[^{}+])+)\}/;
+const REGEXP_DEPENDENCY = /([ \t]*)([A-Za-z_$][\w$]*)(?:\s*\(?\s*(?:module\(?\s*)?["']([^"']+)["']\s*\)?|\s+((?:\s*(?:group|name|version)\s*:\s*(?:"[^"]+"|'[^']+')\s*,?){3}))?/gd;
+const REGEXP_DEPENDENCY_KOTLIN = /([ \t]*)([A-Za-z_$][\w$]*)\((?:\s*(?:(?:module\(\s*)?"([^"]+)"|((?:\s*(?:group|name|version)\s*=\s*"[^"]+"\s*,?){3}))\s*\))?/gd;
+const REGEXP_VERSIONS = /([^\s]+)\s*=\s*(?:"([^":]+)"|'([^':]+)'|(\{(?:\s*(?:require|strictly|prefer|reject(?:All)?)\s*=\s*(?:"[^":]+"|'[^':]+')\s*,?)+\s*\}))/g;
+const REGEXP_VERSIONS_LIB = /([^\s]+)\s*=\s*(?:\{\s*(group|name|module|version(?:\.ref)?)\s*=\s*(?:"([^"]+)"|'([^']+)'|(\{[^}]+\}))\s*,\s*(group|name|module|version(?:\.ref)?)\s*=\s*(?:"([^"]+)"|'([^']+)'|(\{[^}]+\}))(?:\s*,\s*(group|name|module|version(?:\.ref)?)\s*=\s*(?:"([^"]+)"|'([^']+)')|(\{[^}]+\}))?\s*\}|(?:"([^:]+:[^"]+)"|'([^:]+:[^']+)'))/gd;
 function isUpgrade(version, pending) {
-    if (REGEXP_SEMVER.test(pending)) {
+    if (isSemVer(pending)) {
         return true;
     }
-    if (!REGEXP_SEMVER.test(version)) {
+    if (!isSemVer(version)) {
         const previous = version.split(/[.-]/);
         const current = pending.split(/[.-]/);
         for (let i = 0; i < previous.length; ++i) {
@@ -27,15 +33,72 @@ function isUpgrade(version, pending) {
     }
     return false;
 }
-module.exports = function finalize(instance) {
-    const { profileable, dependencies, dataBinding, versionName, versionCode, namespace, applicationId, mainParentDir } = instance.config;
-    if (!profileable && !dependencies && !dataBinding && !versionName && !versionCode && !namespace && !applicationId) {
+function writeMethod(kotlin, named, item, args = '', prefix = 'implementation') {
+    if (/^(?:implementation|api|compileOnly(?:Api)?|runtimeOnly|(?:test|androidTest)(?:Implementation|RuntimeOnly|CompileOnly))$/.test(prefix)) {
+        switch (parseInt(item[3])) {
+            case 0:
+                prefix = 'implementation';
+                break;
+            case 1:
+                prefix = 'api';
+                break;
+            case 2:
+                prefix = 'compileOnly';
+                break;
+            case 3:
+                prefix = 'compileOnlyApi';
+                break;
+            case 4:
+                prefix = 'runtimeOnly';
+                break;
+            case 5:
+                prefix = 'testImplementation';
+                break;
+            case 6:
+                prefix = 'testCompileOnly';
+                break;
+            case 7:
+                prefix = 'testRuntimeOnly';
+                break;
+            case 8:
+                prefix = 'androidTestImplementation';
+                break;
+            case 9:
+                prefix = 'androidTestCompileOnly';
+                break;
+            case 10:
+                prefix = 'androidTestRuntimeOnly';
+                break;
+        }
+    }
+    const [group, name, version] = item;
+    let dependency;
+    if (!name && !version) {
+        dependency = kotlin ? `(${group})` : ' ' + group;
+    }
+    else if (args || named) {
+        dependency = kotlin ? `(group = "${group}", name = "${name}"${version ? `, version = "${version}"` : ''})` : ` group: '${group}', name: '${name}'${version ? `, version: '${version}'` : ''})` + (args.endsWith(',') ? ',' : '');
+    }
+    else {
+        dependency = item.slice(0, 3).join(':');
+        if (dependency.endsWith(':')) {
+            dependency = dependency.substring(0, dependency.length - 1);
+        }
+        dependency = kotlin ? `("${dependency}")` : ` '${dependency}'`;
+    }
+    return prefix + dependency;
+}
+const isLatest = (value) => value === '' || value.startsWith('latest.');
+const isSemVer = (value) => isLatest(value) || REGEXP_SEMVER.test(value);
+const toCamelCase = (value) => value.replace(/-([a-z])/gi, (...capture) => capture[1].toUpperCase());
+function finalize(instance) {
+    const { profileable, dependencies, dataBinding, jvmToolchain, versionName, versionCode, namespace, applicationId, mainParentDir } = instance.config;
+    if (!profileable && !dependencies && !dataBinding && !jvmToolchain && !versionName && !versionCode && !namespace && !applicationId) {
         return;
     }
-    const options = { detect: this.incremental !== 'staging', languageOf: 'gradle' };
-    let { localUri, source, existing, kotlin } = instance.findTemplate(path.join(this.baseDirectory, mainParentDir), "build.gradle", options);
+    let { localUri, source, existing, kotlin = false, language } = instance.findTemplate(path.join(this.baseDirectory, mainParentDir), "build.gradle", { detect: instance.detect(this), languageOf: 'gradle' });
     if (localUri && source && instance.canWrite(localUri, { ownPermissionOnly: true })) {
-        const { javaVersion, dependencyScopes } = instance.config;
+        const javaVersion = instance.config.javaVersion;
         let jvmTarget, modified;
         const upgrade = javaVersion > 0;
         const setModified = (output) => {
@@ -45,10 +108,13 @@ module.exports = function finalize(instance) {
             }
         };
         if (dependencies) {
-            let data;
+            const { dependencyScopes, versionCatalog } = instance.config;
+            let mavenData;
             const hasScope = (value) => (0, types_1.isArray)(dependencyScopes) && dependencyScopes.includes(value) || dependencyScopes === value;
             const snapshot = dependencyScopes === 1 || hasScope('snapshot');
-            const getData = () => data ||= instance.findData('google-maven' + (snapshot ? '-snapshot' : '') + '.json', 'json');
+            const constraints = hasScope('constraints');
+            const checkVersion = (item, version, value) => !value && version.startsWith('{') && version.endsWith('}') ? false : snapshot || constraints && !item[2] || (version.length > 0 && !version.startsWith('$') || !kotlin && !!value?.includes("'")) && isUpgrade(version, item[2]);
+            const getData = () => mavenData ||= instance.findData('google-maven' + (snapshot ? '-snapshot' : '') + '.json', 'json');
             const items = dependencies.map(item => {
                 let [groupId, artifactId, version, type] = item.split(':');
                 if (!version || version === 'maven') {
@@ -61,13 +127,13 @@ module.exports = function finalize(instance) {
                         version = '';
                     }
                 }
-                return [groupId, artifactId, version || (snapshot ? 'latest.integration' : 'latest.release'), type];
+                return [groupId, artifactId, version || (snapshot ? 'latest.integration' : constraints ? '' : 'latest.release'), type];
             });
-            if (dependencyScopes && (data = getData())) {
+            if (dependencyScopes && (mavenData = getData())) {
                 const supplement = [];
                 for (const item of items) {
                     const [gId, id] = item;
-                    const target = data[gId]?.find(group => id === group.artifactId);
+                    const target = mavenData[gId]?.find(group => id === group.artifactId);
                     if (!target) {
                         continue;
                     }
@@ -95,8 +161,8 @@ module.exports = function finalize(instance) {
                                     if (current) {
                                         const t = parseInt(current[3]);
                                         if (t !== type) {
-                                            const rangeVer = REGEXP_SEMVER.test(version);
-                                            if (!REGEXP_SEMVER.test(current[2])) {
+                                            const rangeVer = isSemVer(version);
+                                            if (!isSemVer(current[2])) {
                                                 if (rangeVer || type < t) {
                                                     current[2] = version;
                                                     found = true;
@@ -154,106 +220,201 @@ module.exports = function finalize(instance) {
             if (!kotlin && items.some(seg => seg[1].endsWith('-ktx'))) {
                 setModified(Document.updateGradle(source, ['plugins'], "id 'kotlin-android'", { multiple: true }));
             }
-            const match = /dependencies\s+\{((?:{[^{]*{|{[^}]*}|}[^}]*}|\\}*?|[^{}+])+)\}/.exec(source);
+            const match = REGEXP_DEPENDENCIES.exec(source);
             if (match) {
-                const pattern = kotlin ? /([ \t]*)(implementation|api|compileOnly(?:Api)?|runtimeOnly|(?:test|androidTest)(?:Implementation|RuntimeOnly|CompileOnly))\((?:\s*(?:"([^"]+)"|((?:\s*(?:group|name|version)\s*=\s*"[^"]+"\s*,?){3}))\s*\))?/g : /([ \t]*)(implementation|api|compileOnly(?:Api)?|runtimeOnly|(?:test|androidTest)(?:Implementation|RuntimeOnly|CompileOnly))(?:\s*\(?\s*["']([^"']+)["']\s*\)?|\s+((?:\s*(?:group|name|version)\s*:\s*["'][^"']+["']\s*,?){3}))?/g;
-                let content = match[1], named = false, indent, method;
-                const writeMethod = (item, args, prefix = 'implementation') => {
-                    switch (parseInt(item[3])) {
-                        case 0:
-                            prefix = 'implementation';
-                            break;
-                        case 1:
-                            prefix = 'api';
-                            break;
-                        case 2:
-                            prefix = 'compileOnly';
-                            break;
-                        case 3:
-                            prefix = 'compileOnlyApi';
-                            break;
-                        case 4:
-                            prefix = 'runtimeOnly';
-                            break;
-                        case 5:
-                            prefix = 'testImplementation';
-                            break;
-                        case 6:
-                            prefix = 'testCompileOnly';
-                            break;
-                        case 7:
-                            prefix = 'testRuntimeOnly';
-                            break;
-                        case 8:
-                            prefix = 'androidTestImplementation';
-                            break;
-                        case 9:
-                            prefix = 'androidTestCompileOnly';
-                            break;
-                        case 10:
-                            prefix = 'androidTestRuntimeOnly';
-                            break;
-                    }
-                    let dependency;
-                    if (args || named) {
-                        const [group, name, version] = item;
-                        dependency = kotlin ? `(group = "${group}", name = "${name}", version = "${version}")` : ` group: '${group}', name: '${name}', version: '${version}'` + (args?.endsWith(',') ? ',' : '');
-                    }
-                    else {
-                        dependency = item.slice(0, 3).join(':');
-                        dependency = kotlin ? `("${dependency}")` : ` '${dependency}'`;
-                    }
-                    return prefix + dependency;
-                };
-                while (method = pattern.exec(match[1])) {
-                    let group, name, version;
-                    if (method[3]) {
-                        [group, name, version] = method[3].trim().split(/\s*:\s*/);
-                    }
-                    else if (method[4]) {
-                        const params = /(group|name|version)\s*[=:]\s*["']([^"']+)["']/g;
-                        let param;
-                        while (param = params.exec(method[4])) {
-                            const value = param[2].trim();
-                            switch (param[1]) {
-                                case 'group':
-                                    group = value;
-                                    break;
-                                case 'name':
-                                    name = value;
-                                    break;
-                                case 'version':
-                                    version = value;
-                                    break;
+                const newLine = source.includes('\r\n') ? '\r\n' : '\n';
+                const gradleDir = path.join(this.baseDirectory, 'gradle');
+                const template = instance.findTemplate(gradleDir, "libs.versions.toml", { detect: true, subDir: kotlin ? 'kotlin' : undefined, throwsDoesNotExist: false });
+                let content = match[1], named = false, versioning, indent;
+                if (template.localUri && template.source) {
+                    versioning = kotlin && versionCatalog !== false || versionCatalog;
+                    if (versioning || template.existing) {
+                        const libraries = {};
+                        const versions = {};
+                        let config = template.source, catalog;
+                        while (catalog = REGEXP_VERSIONS.exec(config)) {
+                            versions[catalog[1]] = (catalog[2] || catalog[3] || catalog[4]).trim();
+                        }
+                        while (catalog = REGEXP_VERSIONS_LIB.exec(config)) {
+                            const lib = {};
+                            const inline = catalog[14] || catalog[15];
+                            if (inline) {
+                                [lib.group, lib.name] = inline.trim().split(':');
+                            }
+                            else {
+                                let i = 0;
+                                for (const attr of ['group', 'name', 'module', 'version.ref', 'version']) {
+                                    const index = catalog.findIndex(seg => seg === attr);
+                                    if (index !== -1) {
+                                        lib[attr] = (catalog[i = index + 1] || catalog[i = index + 2] || catalog[i = index + 3]).trim();
+                                        if (attr === 'version') {
+                                            lib.version_indices = catalog.indices[i];
+                                        }
+                                    }
+                                }
+                            }
+                            let { group, name } = lib;
+                            if (lib.module) {
+                                [group, name] = lib.module.split(':');
+                            }
+                            if (group && name) {
+                                const index = items.findIndex(seg => seg[0] === group && seg[1] === name);
+                                if (index !== -1) {
+                                    const item = items[index];
+                                    items.splice(index, 1);
+                                    const ref = lib['version.ref'];
+                                    const version = ref ? versions[ref] : lib.version;
+                                    if (version && checkVersion(item, version)) {
+                                        if (ref) {
+                                            const target = new RegExp(`\\s${(0, types_1.escapePattern)(ref)}\\s*=\\s*(?:"([^":]+)"|'([^':]+)')`, 'd').exec(config);
+                                            if (target) {
+                                                const [start, end] = target.indices[1] || target.indices[2];
+                                                config = (0, util_1.spliceString)(config, start, end, versions[ref] = item[2], REGEXP_VERSIONS_LIB);
+                                            }
+                                        }
+                                        else if (lib.version_indices) {
+                                            const [start, end] = lib.version_indices;
+                                            config = (0, util_1.spliceString)(config, start, end, lib.version = item[2], REGEXP_VERSIONS_LIB);
+                                        }
+                                    }
+                                }
+                                libraries[catalog[1]] = lib;
                             }
                         }
-                        named = true;
-                    }
-                    if (group && name) {
-                        let found = 0, index = -1;
-                        if (version && (index = items.findIndex(seg => seg[0] === group && seg[1] === name)) !== -1) {
-                            found = (!version.startsWith('$') || !kotlin && method[0].includes("'")) && isUpgrade(version, items[index][2]) ? 2 : 1;
+                        if (versioning && items.length > 0) {
+                            let output = '[libraries]' + newLine, outputVer = '';
+                            for (let i = 0, length = items.length; i < length; ++i) {
+                                const item = items[i];
+                                const [group, name, version] = item;
+                                let key = group.replaceAll('.', '-');
+                                if (libraries[key]) {
+                                    key += '-' + name.replaceAll('.', '-');
+                                }
+                                let versionRef;
+                                found: {
+                                    for (const ref in versions) {
+                                        if (versions[ref] === version) {
+                                            for (const lib in libraries) {
+                                                if (libraries[lib]['version.ref'] === ref && (libraries[lib].group === group || libraries[lib].module?.startsWith(group + ':'))) {
+                                                    versionRef = ref;
+                                                    break found;
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                                if (!versionRef) {
+                                    if (versions[versionRef = toCamelCase(name)]) {
+                                        const prefix = group.split('.').filter(seg => seg !== name).pop();
+                                        if (prefix) {
+                                            versionRef = toCamelCase(prefix + '-' + name);
+                                        }
+                                        else {
+                                            const baseRef = versionRef;
+                                            let j = 1;
+                                            do {
+                                                versionRef = baseRef + j++;
+                                            } while (versions[versionRef]);
+                                        }
+                                    }
+                                    versions[versionRef] = version;
+                                    outputVer += versionRef + ` = "${version}"` + newLine;
+                                }
+                                output += key + ` = { group = "${group}", name = "${name}", version.ref = "${versionRef}" }` + newLine;
+                                item[0] = 'libs.' + key.replaceAll('-', '.');
+                                item[1] = '';
+                                item[2] = '';
+                                libraries[key] = { group, name, "version.ref": versionRef };
+                            }
+                            let section = /\[libraries\]\s*/.exec(config);
+                            const writeOutput = (value) => (0, util_1.spliceString)(config, section.index, section.index + section[0].length, value);
+                            if (section) {
+                                config = writeOutput(output);
+                            }
+                            else {
+                                config += output;
+                            }
+                            if (outputVer) {
+                                outputVer = '[versions]' + newLine + outputVer;
+                                if (section = /\[versions\]\s*/.exec(config)) {
+                                    config = writeOutput(outputVer);
+                                }
+                                else {
+                                    config = outputVer + newLine + config;
+                                }
+                            }
+                            REGEXP_VERSIONS.lastIndex = 0;
                         }
-                        if (found) {
-                            if (found === 2) {
-                                content = content.replace(method[0].trim(), writeMethod(items[index], method[4], method[2]));
-                                modified = true;
+                        if (instance.canWrite(template.localUri, { ownPermissionOnly: true }) && Document.createDir(gradleDir)) {
+                            try {
+                                if (instance.writeFile(template.localUri, config, { encoding: 'utf-8', ownPermissionOnly: true, throwsPermission: true })) {
+                                    this.add(template.localUri);
+                                }
+                            }
+                            catch (err) {
+                                this.writeFail(["Unable to write file", path.basename(template.localUri)], err, 8192);
                             }
-                            items.splice(index, 1);
                         }
-                    }
-                    if (method[1]) {
-                        indent = method[1];
+                        REGEXP_VERSIONS_LIB.lastIndex = 0;
                     }
                 }
-                if (items.length) {
-                    const newline = process.platform === 'win32' ? '\r\n' : '\n';
+                if (items.length > 0) {
+                    if (!versioning) {
+                        const pattern = kotlin ? REGEXP_DEPENDENCY_KOTLIN : REGEXP_DEPENDENCY;
+                        pattern.lastIndex = 0;
+                        let method;
+                        while (method = pattern.exec(content)) {
+                            let group, name, version;
+                            if (method[1]) {
+                                indent ||= method[1];
+                            }
+                            if (method[3]) {
+                                [group, name, version] = method[3].trim().split(/\s*:\s*/);
+                            }
+                            else if (method[4]) {
+                                const params = /(group|name|version)\s*[=:]\s*(?:"([^"]+)"|'([^']+)')/g;
+                                let param;
+                                while (param = params.exec(method[4])) {
+                                    const value = (param[2] || param[3]).trim();
+                                    switch (param[1]) {
+                                        case 'group':
+                                            group = value;
+                                            break;
+                                        case 'name':
+                                            name = value;
+                                            break;
+                                        case 'version':
+                                            version = value;
+                                            break;
+                                    }
+                                }
+                                named = true;
+                            }
+                            if (group && name) {
+                                const index = items.findIndex(seg => seg[0] === group && seg[1] === name);
+                                if (index !== -1) {
+                                    const item = items[index];
+                                    items.splice(index, 1);
+                                    if (!version) {
+                                        if (constraints) {
+                                            continue;
+                                        }
+                                        version = '';
+                                    }
+                                    if (checkVersion(item, version, method[0])) {
+                                        content = (0, util_1.spliceString)(content, method.index, method.index + method[0].length, method[1] + writeMethod(kotlin, named, item, method[4], method[2]) + newLine, pattern);
+                                        modified = true;
+                                    }
+                                }
+                            }
+                        }
+                    }
                     indent ||= (0, util_1.getIndent)(source);
-                    content = items.reduce((a, b) => a + indent + writeMethod(b) + newline, content);
+                    content = items.reduce((a, b) => a + indent + writeMethod(kotlin, named, b) + newLine, content);
                     modified = true;
                 }
                 if (modified || !existing) {
-                    setModified(source.substring(0, match.index) + `dependencies {${content}}` + source.substring(match.index + match[0].length));
+                    setModified((0, util_1.spliceString)(source, match.index, match.index + match[0].length, `dependencies {${content}}`));
                 }
             }
             if (items.some(seg => seg[0] === 'androidx.compose.ui')) {
@@ -263,9 +424,12 @@ module.exports = function finalize(instance) {
                     output = Document.updateGradle(output, ['android', 'buildFeatures'], 'compose = true');
                 }
                 else {
-                    output = Document.updateGradle(output, ['plugins'], "id 'org.jetbrains.kotlin.android'", { upgrade: true, multiple: true, addendum: `version '${instance.findVersion('org.jetbrains.kotlin:kotlin-stdlib', "1.9.24")}'` });
+                    const stdLib = instance.findVersion('org.jetbrains.kotlin:kotlin-stdlib', "2.0.20");
+                    output = Document.updateGradle(output, ['plugins'], "id 'org.jetbrains.kotlin.android'", { upgrade: true, multiple: true, addendum: `version '${stdLib}'` });
                     output = Document.updateGradle(output, ['android', 'buildFeatures'], "compose true");
-                    output = Document.updateGradle(output, ['android', 'composeOptions'], `kotlinCompilerExtensionVersion '${instance.findVersion('kotlinCompilerExtensionVersion', "1.5.14")}'`, true);
+                    if (stdLib.startsWith('1.')) {
+                        output = Document.updateGradle(output, ['android', 'composeOptions'], `kotlinCompilerExtensionVersion '${instance.findVersion('kotlinCompilerExtensionVersion', "1.5.14")}'`, true);
+                    }
                     if (upgrade) {
                         output = Document.updateGradle(output, ['android', 'kotlinOptions'], `jvmTarget = '${javaVersion}'`, true);
                     }
@@ -291,6 +455,16 @@ module.exports = function finalize(instance) {
             }
             setModified(output);
         }
+        if (jvmToolchain) {
+            let output = source;
+            if (language === 'java') {
+                output = Document.updateGradle(output, ['java', 'toolchain'], kotlin ? `languageVersion.set(JavaLanguageVersion.of(${jvmToolchain}))` : `languageVersion = JavaLanguageVersion.of(${jvmToolchain})`, true);
+            }
+            else {
+                output = Document.updateGradle(output, ['kotlin'], kotlin ? `jvmToolchain(${jvmToolchain})` : 'jvmToolchain ' + jvmToolchain, true);
+            }
+            setModified(output);
+        }
         if (!existing) {
             const targetAPI = instance.targetAPI;
             let output = source;
@@ -372,16 +546,55 @@ module.exports = function finalize(instance) {
         }
     }
     if (!existing) {
-        ({ localUri, source, existing, kotlin } = instance.findTemplate(this.baseDirectory, "build.gradle", { ...options, subDir: 'static' }));
-        if (localUri && source && instance.canWrite(localUri, { ownPermissionOnly: true })) {
+        const template = instance.findTemplate(this.baseDirectory, "build.gradle", { detect: instance.detect(this), languageOf: 'gradle', subDir: 'static' });
+        if (template.localUri && template.source && instance.canWrite(template.localUri, { ownPermissionOnly: true })) {
             try {
-                if (instance.writeFile(localUri, source, { encoding: 'utf-8', ownPermissionOnly: true, throwsPermission: true })) {
-                    this.add(localUri);
+                if (instance.writeFile(template.localUri, template.source, { encoding: 'utf-8', ownPermissionOnly: true, throwsPermission: true })) {
+                    this.add(template.localUri);
                 }
             }
             catch (err) {
-                this.writeFail(["Unable to write file", path.basename(localUri)], err, 8192);
+                this.writeFail(["Unable to write file", path.basename(template.localUri)], err, 8192);
+            }
+        }
+        try {
+            const projectDir = instance.resolveDir('project');
+            if (projectDir) {
+                (function recurse(subDir, targetDir) {
+                    fs.readdirSync(subDir, { withFileTypes: true }).forEach(item => {
+                        const srcName = path.join(subDir, item.name);
+                        if (item.isDirectory()) {
+                            switch (/^\$\{([^}]+)\}$/.exec(item.name)?.[1]) {
+                                case 'app':
+                                    if (instance.config.mainParentDir) {
+                                        recurse.call(this, srcName, path.join(targetDir, instance.config.mainParentDir));
+                                    }
+                                    break;
+                                case 'src':
+                                    if (instance.config.mainSrcDir) {
+                                        recurse.call(this, srcName, path.join(targetDir, instance.config.mainSrcDir));
+                                    }
+                                    break;
+                                default:
+                                    recurse.call(this, srcName, path.join(targetDir, item.name));
+                                    break;
+                            }
+                        }
+                        else if (item.isFile()) {
+                            const destDir = path.join(this.baseDirectory, targetDir);
+                            const destName = path.join(destDir, item.name);
+                            if (!Document.isPath(destName) && instance.canWrite(destName, { ownPermissionOnly: true }) && Document.createDir(destDir)) {
+                                fs.copyFileSync(srcName, destName);
+                                this.add(destName);
+                            }
+                        }
+                    });
+                }).call(this, projectDir, './');
             }
         }
+        catch (err) {
+            this.writeFail("Path not found", err, 32);
+        }
     }
-};
+}
+module.exports = finalize;

package/extensions/gradle/settings/index.js

@@ -2,12 +2,12 @@
 const path = require("path");
 const util_1 = require("@e-mc/document/util");
 const parse_1 = require("@e-mc/document/parse");
-module.exports = function finalize(instance) {
+function finalize(instance) {
     const { dependencies, projectName, mainParentDir } = instance.config;
     if (!dependencies && !projectName) {
         return;
     }
-    let { localUri, source, existing, kotlin } = instance.findTemplate(this.baseDirectory, "settings.gradle", { detect: this.incremental !== 'staging', languageOf: 'gradle' });
+    let { localUri, source, existing, kotlin } = instance.findTemplate(this.baseDirectory, "settings.gradle", { detect: instance.detect(this), languageOf: 'gradle' });
     if (localUri && source && instance.canWrite(localUri, { ownPermissionOnly: true })) {
         const targetName = projectName?.replace(/"/g, '\\"');
         let modified;
@@ -75,4 +75,5 @@ module.exports = function finalize(instance) {
             }
         }
     }
-};
+}
+module.exports = finalize;