@pi-r/android 0.3.1 → 0.6.0

package/extensions/app/manifest/index.js

@@ -142,27 +142,26 @@ function finalize(instance) {
                     return;
                 }
                 const app = domutils.findOne(elem => elem.tagName === 'application', dom, true);
-                if (!app) {
-                    return;
-                }
-                for (const { name, resource, value } of metaData) {
-                    if (name && (resource || value)) {
-                        let item = domutils.findOne(elem => elem.tagName === 'meta-data' && elem.attribs['android:name'] === name, app.childNodes);
-                        if (!item) {
-                            domutils.appendChild(app, item = new domhandler.Element('meta-data', { 'android:name': name }));
-                            domutils.append(item, new domhandler.Text('\n'));
-                        }
-                        else if (item.attribs['android:resource'] === resource || item.attribs['android:value'] === value) {
-                            continue;
-                        }
-                        if (resource) {
-                            item.attribs['android:resource'] = resource;
-                        }
-                        if (value) {
-                            item.attribs['android:value'] = value;
+                if (app) {
+                    for (const { name, resource, value } of metaData) {
+                        if (name && (resource || value)) {
+                            let item = domutils.findOne(elem => elem.tagName === 'meta-data' && elem.attribs['android:name'] === name, app.childNodes);
+                            if (!item) {
+                                domutils.appendChild(app, item = new domhandler.Element('meta-data', { 'android:name': name }));
+                                domutils.append(item, new domhandler.Text('\n'));
+                            }
+                            else if (item.attribs['android:resource'] === resource || item.attribs['android:value'] === value) {
+                                continue;
+                            }
+                            if (resource) {
+                                item.attribs['android:resource'] = resource;
+                            }
+                            if (value) {
+                                item.attribs['android:value'] = value;
+                            }
+                            source = domserializer.default(dom, { xmlMode: true });
+                            modified = true;
                         }
-                        source = domserializer.default(dom, { xmlMode: true });
-                        modified = true;
                     }
                 }
             }), { xmlMode: true, decodeEntities: false }).end(source);

package/extensions/gradle/dependencies/index.js

@@ -4,6 +4,30 @@ const path = require("path");
 const util_1 = require("@e-mc/document/util");
 const types_1 = require("@e-mc/types");
 const Document = require("@e-mc/document");
+const REGEXP_SEMVER = /^((\s*,\s*)?[([\]]((\s*,\s*)?\d+\.\d+(\s*,\s*)?)+[)\][])+$/;
+function isUpgrade(version, pending) {
+    if (REGEXP_SEMVER.test(pending)) {
+        return true;
+    }
+    if (!REGEXP_SEMVER.test(version)) {
+        const previous = version.split(/[.-]/);
+        const current = pending.split(/[.-]/);
+        for (let i = 0; i < previous.length; ++i) {
+            const a = parseInt(previous[i]);
+            const b = parseInt(current[i]);
+            if (isNaN(a) && isNaN(b)) {
+                continue;
+            }
+            if (isNaN(a) || b > a) {
+                return true;
+            }
+            if (isNaN(b) || b < a) {
+                break;
+            }
+        }
+    }
+    return false;
+}
 function finalize(instance) {
     const config = instance.config;
     const { profileable, dependencies, dataBinding, versionName, versionCode } = config;
@@ -13,7 +37,7 @@ function finalize(instance) {
     const detect = this.incremental !== 'staging';
     let { localUri, source, existing, kotlin } = instance.findTemplate(path.join(this.baseDirectory, config.mainParentDir), "build.gradle" /* GRADLE.FILENAME */, { detect, languageOf: 'gradle' });
     if (localUri && source && instance.canWrite(localUri, { ownPermissionOnly: true })) {
-        let { namespace, javaVersion } = config, jvmTarget, modified;
+        let { namespace, javaVersion, dependencyScopes } = config, jvmTarget, modified;
         const upgrade = javaVersion > 0;
         const setModified = (output) => {
             if (output !== source) {
@@ -22,24 +46,175 @@ function finalize(instance) {
             }
         };
         if (dependencies) {
-            const items = dependencies.map(item => item.split(':'));
-            if (!kotlin && items.some(value => value[1].endsWith('-ktx'))) {
+            let data;
+            const hasScope = (value) => (0, types_1.isArray)(dependencyScopes) && dependencyScopes.includes(value) || dependencyScopes === value;
+            const snapshot = hasScope('snapshot');
+            const getData = () => data || (data = instance.findData('google-maven' + (snapshot ? '-snapshot' : '') + '.json', 'json'));
+            const items = dependencies.map(item => {
+                let [groupId, artifactId, version, type] = item.split(':');
+                if (!version || version === 'maven') {
+                    const maven = getData();
+                    let artifact;
+                    if (maven && (artifact = maven[groupId]?.find(child => child.artifactId === artifactId))) {
+                        version = artifact.version;
+                    }
+                    else {
+                        version = '';
+                    }
+                }
+                return [groupId, artifactId, version || (snapshot ? 'latest.integration' : 'latest.release'), type];
+            });
+            if (dependencyScopes && (data = getData())) {
+                const supplement = [];
+                for (const item of items) {
+                    const [gId, id] = item;
+                    const target = data[gId]?.find(group => id === group.artifactId);
+                    if (!target) {
+                        continue;
+                    }
+                    if (target.dependencies) {
+                        let found;
+                        for (const { groupId, artifactId, version, scope } of target.dependencies) {
+                            if (scope && (dependencyScopes === true || hasScope(scope))) {
+                                let type = -1;
+                                switch (scope) {
+                                    case 'compile':
+                                        type = 0 /* DEPENDENCY_TYPE.IMPLEMENTATION */;
+                                        break;
+                                    case 'provided':
+                                        type = 2 /* DEPENDENCY_TYPE.COMPILE_ONLY */;
+                                        break;
+                                    case 'runtime':
+                                        type = 4 /* DEPENDENCY_TYPE.RUNTIME_ONLY */;
+                                        break;
+                                    case 'test':
+                                        type = 5 /* DEPENDENCY_TYPE.TEST_IMPLEMENTATION */;
+                                        break;
+                                }
+                                if (type !== -1) {
+                                    const current = supplement.find(seg => seg[0] === groupId && seg[1] === artifactId);
+                                    if (current) {
+                                        const t = parseInt(current[3]);
+                                        if (t !== type) {
+                                            const rangeVer = REGEXP_SEMVER.test(version);
+                                            if (!REGEXP_SEMVER.test(current[2])) {
+                                                if (rangeVer || type < t) {
+                                                    current[2] = version;
+                                                    found = true;
+                                                }
+                                            }
+                                            else if (rangeVer && type < t) {
+                                                current[2] = version;
+                                                found = true;
+                                            }
+                                            current[3] = '0';
+                                        }
+                                        else if (isUpgrade(current[2], version)) {
+                                            current[2] = version;
+                                            found = true;
+                                        }
+                                    }
+                                    else {
+                                        supplement.push([groupId, artifactId, version, type.toString()]);
+                                        found = true;
+                                    }
+                                }
+                            }
+                        }
+                        if (found && (snapshot || isUpgrade(item[2], target.version))) {
+                            item[2] = target.version;
+                        }
+                    }
+                    break;
+                }
+                for (const item of supplement) {
+                    const [groupId, artifactId] = item;
+                    const index = items.findIndex(seg => seg[0] === groupId && seg[1] === artifactId);
+                    if (index === -1) {
+                        items.push(item);
+                    }
+                    else if (snapshot) {
+                        item[3] = items[index][3];
+                        items[index] = item;
+                    }
+                }
+            }
+            items.sort((a, b) => {
+                const tA = parseInt(a[3]) || 0;
+                const tB = parseInt(b[3]) || 0;
+                if (tA !== tB) {
+                    return tA - tB;
+                }
+                const gA = a[0];
+                const gB = b[0];
+                if (gA !== gB) {
+                    return gA < gB ? -1 : 1;
+                }
+                return a[1] < b[1] ? -1 : 1;
+            });
+            if (!kotlin && items.some(seg => seg[1].endsWith('-ktx'))) {
                 setModified(Document.updateGradle(source, ['plugins'], "id 'kotlin-android'", { multiple: true }));
             }
-            const match = /dependencies\s+\{((?:{[^}]*}|(?![{}])[\S\s])+)\}/.exec(source);
+            const match = /dependencies\s+\{((?:{[^{]*{|{[^}]*}|}[^}]*}|\\}*?|[^{}+])+)\}/.exec(source);
             if (match) {
-                const writeImpl = (item) => 'implementation' + (kotlin ? `("${item.join(':')}")` : ` '${item.join(':')}'`);
-                const pattern = kotlin ? /([ \t]*)implementation\((?:\s*"([^"]+)"\s*\))?/g : /([ \t]*)implementation(?:\s*\(?\s*["']([^"']+)["']\s*\)?|\s+((?:\s*(?:group|name|version)\s*:\s*["'][^"']+["']\s*,?){3}))?/g;
-                let content = match[1], indent, impl;
-                while (impl = pattern.exec(match[1])) {
+                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 /* DEPENDENCY_TYPE.IMPLEMENTATION */:
+                            prefix = 'implementation';
+                            break;
+                        case 1 /* DEPENDENCY_TYPE.API */:
+                            prefix = 'api';
+                            break;
+                        case 2 /* DEPENDENCY_TYPE.COMPILE_ONLY */:
+                            prefix = 'compileOnly';
+                            break;
+                        case 3 /* DEPENDENCY_TYPE.COMPILE_ONLY_API */:
+                            prefix = 'compileOnlyApi';
+                            break;
+                        case 4 /* DEPENDENCY_TYPE.RUNTIME_ONLY */:
+                            prefix = 'runtimeOnly';
+                            break;
+                        case 5 /* DEPENDENCY_TYPE.TEST_IMPLEMENTATION */:
+                            prefix = 'testImplementation';
+                            break;
+                        case 6 /* DEPENDENCY_TYPE.TEST_COMPILE_ONLY */:
+                            prefix = 'testCompileOnly';
+                            break;
+                        case 7 /* DEPENDENCY_TYPE.TEST_RUNTIME_ONLY */:
+                            prefix = 'testRuntimeOnly';
+                            break;
+                        case 8 /* DEPENDENCY_TYPE.ANDROID_TEST_IMPLEMENTATION */:
+                            prefix = 'androidTestImplementation';
+                            break;
+                        case 9 /* DEPENDENCY_TYPE.ANDROID_TEST_COMPILE_ONLY */:
+                            prefix = 'androidTestCompileOnly';
+                            break;
+                        case 10 /* DEPENDENCY_TYPE.ANDROID_TEST_RUNTIME_ONLY */:
+                            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 (impl[2]) {
-                        [group, name, version] = impl[2].trim().split(/\s*:\s*/);
+                    if (method[3]) {
+                        [group, name, version] = method[3].trim().split(/\s*:\s*/);
                     }
-                    else if (impl[3]) {
-                        const method = /(group|name|version)\s*:\s*["']([^"']+)["']/g;
+                    else if (method[4]) {
+                        const params = /(group|name|version)\s*[=:]\s*["']([^"']+)["']/g;
                         let param;
-                        while (param = method.exec(impl[3])) {
+                        while (param = params.exec(method[4])) {
                             const value = param[2].trim();
                             switch (param[1]) {
                                 case 'group':
@@ -53,66 +228,45 @@ function finalize(instance) {
                                     break;
                             }
                         }
+                        named = true;
                     }
                     if (group && name) {
                         let found = 0, index = -1;
                         if (version && (index = items.findIndex(seg => seg[0] === group && seg[1] === name)) !== -1) {
-                            found = 1;
-                            if (version[0] !== '$' || !kotlin && impl[0].indexOf("'") !== -1) {
-                                const semver = /^((\s*,\s*)?[([\]]((\s*,\s*)?\d+\.\d+(\s*,\s*)?)+[)\][])+$/;
-                                const pending = items[index][2];
-                                if (semver.test(pending)) {
-                                    found = 2;
-                                }
-                                else if (!semver.test(version)) {
-                                    const getArray = (value) => value.split(/[.-]/).map(seg => +seg);
-                                    const current = getArray(pending);
-                                    const previous = getArray(version);
-                                    for (let i = 0; i < previous.length; ++i) {
-                                        const a = previous[i];
-                                        const b = current[i];
-                                        if (isNaN(a) || b > a) {
-                                            found = 2;
-                                            break;
-                                        }
-                                        if (isNaN(b) || b < a) {
-                                            break;
-                                        }
-                                    }
-                                }
-                            }
+                            found = (!version.startsWith('$') || !kotlin && method[0].includes("'")) && isUpgrade(version, items[index][2]) ? 2 : 1;
                         }
                         if (found) {
                             if (found === 2) {
-                                content = content.replace(impl[0].trim(), writeImpl(items[index]));
+                                content = content.replace(method[0].trim(), writeMethod(items[index], method[4], method[2]));
                                 modified = true;
                             }
                             items.splice(index, 1);
                         }
                     }
-                    if (impl[1]) {
-                        indent = impl[1];
+                    if (method[1]) {
+                        indent = method[1];
                     }
                 }
                 if (items.length) {
+                    const newline = process.platform === 'win32' ? '\r\n' : '\n';
                     indent || (indent = (0, util_1.getIndent)(source));
-                    content = items.reduce((a, b) => a + indent + writeImpl(b) + '\n', content);
+                    content = items.reduce((a, b) => a + indent + writeMethod(b) + newline, content);
                     modified = true;
                 }
                 if (modified || !existing) {
                     setModified(source.substring(0, match.index) + `dependencies {${content}}` + source.substring(match.index + match[0].length));
                 }
             }
-            if (items.some(value => value[0] === 'androidx.compose.ui')) {
+            if (items.some(seg => seg[0] === 'androidx.compose.ui')) {
                 let output = source;
                 if (kotlin) {
                     output = Document.updateGradle(output, ['plugins'], 'kotlin("android")');
                     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.10" /* VERSIONS.KOTLIN_STDLIB */)}'` });
+                    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.21" /* VERSIONS.KOTLIN_STDLIB */)}'` });
                     output = Document.updateGradle(output, ['android', 'buildFeatures'], "compose true");
-                    output = Document.updateGradle(output, ['android', 'composeOptions'], `kotlinCompilerExtensionVersion '${instance.findVersion('kotlinCompilerExtensionVersion', "1.5.5" /* VERSIONS.KOTLIN_COMPILER */)}'`, true);
+                    output = Document.updateGradle(output, ['android', 'composeOptions'], `kotlinCompilerExtensionVersion '${instance.findVersion('kotlinCompilerExtensionVersion', "1.5.7" /* VERSIONS.KOTLIN_COMPILER */)}'`, true);
                     if (upgrade) {
                         output = Document.updateGradle(output, ['android', 'kotlinOptions'], `jvmTarget = '${javaVersion}'`, true);
                     }

package/extensions/gradle/settings/index.js

@@ -8,7 +8,7 @@ function finalize(instance) {
     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" /* GRADLE.FILENAME */, { detect: this.incremental !== 'staging', languageOf: 'gradle' });
     if (localUri && source && instance.canWrite(localUri, { ownPermissionOnly: true })) {
         let targetName = projectName?.replace(/"/g, '\\"'), modified;
         if (existing) {

package/extensions/task/index.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const path = require("path");
 const fs = require("fs");
 const child_process = require("child_process");
+const which = require("which");
 const types_1 = require("@e-mc/types");
 const Document = require("@e-mc/document");
 const checkWin32 = (value) => value === "gradlew" /* STRINGS.GRADLEW */ && process.platform === 'win32' ? value + '.bat' : value;
@@ -28,15 +29,14 @@ async function finalize(instance) {
     }
     const settings = instance.settings.extensions?.task || {};
     const exec = settings.exec;
-    let { broadcastId, baseDirectory } = this, command = settings.command, uid, gid, title, filename, foundCwd;
+    let { broadcastId, baseDirectory } = this, command = settings.command, uid, gid, title, filename, altname, foundDir;
     if (command) {
-        if (command.indexOf('mvn') !== -1) {
-            title = 'maven';
+        if (command.includes('mvn')) {
+            title = "maven" /* STRINGS.MAVEN */;
         }
         else {
-            title = /([^\\/]+?)(?:\.[a-z]+)?$/i.exec(command)?.[1] || 'SPAWN';
+            title = /([^\\/]+?)(?:\.[a-z]+)?$/i.exec(command)?.[1] || 'spawn';
         }
-        command = path.normalize(command);
         if (!/[\\/]/.test(command = path.normalize(command))) {
             filename = checkWin32(command);
         }
@@ -45,21 +45,28 @@ async function finalize(instance) {
     else {
         filename = checkWin32("gradlew" /* STRINGS.GRADLEW */);
         command = '.' + path.sep + filename;
-        title = 'gradle';
+        title = "gradle" /* STRINGS.GRADLE */;
+        altname = "gradle" /* STRINGS.GRADLE */;
     }
     if (filename) {
         try {
             let appDir = baseDirectory;
-            while (!(foundCwd = fs.existsSync(path.join(appDir, filename)))) {
+            while (!(foundDir = fs.existsSync(path.join(appDir, filename)))) {
                 const parent = path.dirname(appDir);
                 if (parent === appDir) {
                     break;
                 }
                 appDir = parent;
             }
-            if (foundCwd) {
+            if (foundDir) {
                 baseDirectory = appDir;
             }
+            else if (altname) {
+                const bin = which.sync(altname, { nothrow: true });
+                if (bin) {
+                    command = Document.sanitizeCmd(bin);
+                }
+            }
         }
         catch {
         }
@@ -90,7 +97,7 @@ async function finalize(instance) {
                     resolve();
                 }
                 else {
-                    reject((0, types_1.errorValue)(message || (!foundCwd && code === 1 ? "Unable to execute file" /* ERR_MESSAGE.EXECUTE_FILE */ : "Unknown" /* ERR_MESSAGE.UNKNOWN */), "Error code" /* ERR_MESSAGE.ERROR_CODE */ + ': ' + code));
+                    reject((0, types_1.errorValue)(message || (!foundDir && code === 1 ? "Unable to execute file" /* ERR_MESSAGE.EXECUTE_FILE */ : "Unknown" /* ERR_MESSAGE.UNKNOWN */), "Error code" /* ERR_MESSAGE.ERROR_CODE */ + ': ' + code));
                 }
             })
                 .on('error', err => reject(err));

package/index.d.ts

@@ -1,7 +1,7 @@
-import type { IFileManager } from '@e-mc/types/types/lib';
-
-import type { AndroidDocumentConstructor, DocumentAsset } from './types';
-
-declare const Android: AndroidDocumentConstructor<IFileManager<DocumentAsset>>;
-
+import type { IFileManager } from '@e-mc/types/types/lib';
+
+import type { AndroidDocumentConstructor, DocumentAsset } from './types';
+
+declare const Android: AndroidDocumentConstructor<IFileManager<DocumentAsset>>;
+
 export = Android;

package/index.js

@@ -21,6 +21,7 @@ class AndroidDocument extends Document {
             namespace: undefined,
             profileable: undefined,
             dependencies: undefined,
+            dependencyScopes: undefined,
             commands: undefined
         };
         this.elements = [];
@@ -56,7 +57,7 @@ class AndroidDocument extends Document {
     }
     init(assets, config) {
         if (config) {
-            const { targetAPI, mainParentDir, mainSrcDir, mainActivityFile, javaVersion, projectName, versionName, versionCode = 0, manifest, namespace, profileable, dependencies, dataBinding, commands, directories, elements, extensionData } = config;
+            const { targetAPI, mainParentDir, mainSrcDir, mainActivityFile, javaVersion, projectName, versionName, versionCode = 0, manifest, namespace, profileable, dependencies, dependencyScopes, dataBinding, commands, directories, elements, extensionData } = config;
             const target = this.config;
             if (projectName) {
                 target.projectName = projectName;
@@ -76,7 +77,7 @@ class AndroidDocument extends Document {
             if (versionName) {
                 target.versionName = versionName;
             }
-            if (manifest) {
+            if ((0, types_1.isPlainObject)(manifest)) {
                 target.manifest = manifest;
             }
             if (profileable !== undefined) {
@@ -89,7 +90,7 @@ class AndroidDocument extends Document {
                 target.commands = commands;
             }
             if (javaVersion) {
-                target.javaVersion = +(typeof javaVersion === 'string' ? javaVersion.toString().replace(/_/g, '.') : javaVersion);
+                target.javaVersion = typeof javaVersion === 'string' ? +javaVersion.replace(/_/g, '.') : javaVersion;
             }
             if (dataBinding) {
                 target.dataBinding = true;
@@ -97,6 +98,9 @@ class AndroidDocument extends Document {
             if ((0, types_1.isArray)(dependencies)) {
                 target.dependencies = dependencies;
             }
+            if (dependencyScopes) {
+                target.dependencyScopes = dependencyScopes;
+            }
             if (targetAPI) {
                 this.targetAPI = targetAPI;
             }
@@ -198,6 +202,18 @@ class AndroidDocument extends Document {
         }
         return { kotlin, language };
     }
+    findData(filename, format) {
+        let localUri;
+        if ((localUri = this.resolveDir('data', filename)) || Document.isPath(localUri = path.join(__dirname, 'data', filename))) {
+            try {
+                return this.tryParse(fs.readFileSync(localUri, 'utf-8'), format || path.extname(localUri).substring(1));
+            }
+            catch (err) {
+                this.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, path.basename(localUri)], err, 32 /* LOG_TYPE.FILE */);
+            }
+        }
+        return null;
+    }
     detectKts(...paths) {
         try {
             const file = path.join(...paths);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-r/android",
-  "version": "0.3.1",
+  "version": "0.6.0",
   "description": "Android document constructor for E-mc.",
   "main": "index.js",
   "publishConfig": {
@@ -20,8 +20,9 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/pi-r#readme",
   "dependencies": {
-    "@e-mc/document": "^0.6.0",
-    "@e-mc/types": "^0.6.0",
-    "htmlparser2": "^9.0.0"
+    "@e-mc/document": "^0.8.0",
+    "@e-mc/types": "^0.8.0",
+    "htmlparser2": "^9.0.0",
+    "which": "^2.0.2"
   }
 }

package/template/java+kotlin/static/build.gradle

@@ -1,5 +1,5 @@
 plugins {
     id 'com.android.application' version '8.2.0' apply false
     id 'com.android.library' version '8.2.0' apply false
-    id 'org.jetbrains.kotlin.android' version '1.9.10' apply false
+    id 'org.jetbrains.kotlin.android' version '1.9.21' apply false
 }

package/template/kotlin/build.gradle.kts

@@ -38,7 +38,7 @@ java {
 }
 
 dependencies {
-    implementation("org.jetbrains.kotlin:kotlin-stdlib:1.9.10")
+    implementation("org.jetbrains.kotlin:kotlin-stdlib:1.9.21")
     implementation("androidx.core:core-ktx:1.12.0")
     testImplementation("junit:junit:4.13.2")
     androidTestImplementation("androidx.test.ext:junit:1.1.5")

package/template/kotlin/static/build.gradle.kts

@@ -1,5 +1,5 @@
 plugins {
     id("com.android.application") version "8.2.0" apply false
     id("com.android.library") version "8.2.0" apply false
-    id("org.jetbrains.kotlin.android") version "1.9.10" apply false
+    id("org.jetbrains.kotlin.android") version "1.9.21" apply false
 }

package/types/index.d.ts

@@ -2,15 +2,15 @@ import type { FinalizedElement } from '@e-mc/types/lib/squared';
 
 import type { DocumentConstructor, IDocument, IFileManager } from '@e-mc/types/lib';
 import type { ExternalAsset } from '@e-mc/types/lib/asset';
-import type { DocumentDirectory as IDocumentDirectory, DocumentModule as IDocumentModule, ExecAction } from '@e-mc/types/lib/settings';
+import type { DocumentModule as IDocumentModule, DocumentSettings as IDocumentSettings, ExecAction } from '@e-mc/types/lib/settings';
 
-import type { DocumentOutput } from './squared';
+import type { DocumentOutput, MavenScopes } from './squared';
 
 interface DocumentDirectory extends IDocumentDirectory {
     template?: string;
 }
 
-interface AndroidDocumentSettings extends PlainObject {
+interface AndroidDocumentSettings extends Pick<IDocumentSettings, "users" | "directory">, PlainObject {
     extensions?: {
         task?: {
             exec?: ExecAction;
@@ -20,7 +20,6 @@ interface AndroidDocumentSettings extends PlainObject {
     language?: {
         gradle?: "java" | "kotlin" | "java+kotlin";
     };
-    directory?: DocumentDirectory;
 }
 
 type LanguageType = "gradle";
@@ -52,11 +51,20 @@ export interface FindTemplateOptions {
     subDir?: ArrayOf<string>;
 }
 
+export interface MavenArtifact {
+    groupId: string;
+    artifactId: string;
+    version: string;
+    scope?: MavenScopes;
+    dependencies?: MavenArtifact[];
+}
+
 export interface IAndroidDocument<T extends IFileManager<U>, U extends DocumentAsset = DocumentAsset> extends IDocument<T, U>, Pick<DocumentOutput, DocumentProperties> {
     config: UserConfig;
     elements: FinalizedElement[];
     extensionData: PlainObject;
     findTemplate(baseDir: string, filename: string, options?: FindTemplateOptions): TemplateData;
+    findData<V = AnyObject>(filename: string, format?: string): Null<V>;
     detectKts(...paths: string[]): Null<boolean>;
     get settings(): AndroidDocumentSettings;
 }

package/types/squared.d.ts

@@ -9,6 +9,7 @@ export interface DocumentOutput {
     namespace?: string;
     profileable?: boolean | StringOfArray;
     dependencies?: string[];
+    dependencyScopes?: boolean | ArrayOf<DependencyScopes | "snapshot">;
     directories?: ControllerSettingsDirectoryUI;
     elements?: FinalizedElement[];
     projectName?: string;
@@ -50,4 +51,6 @@ export interface ControllerSettingsDirectoryUI extends IControllerSettingsDirect
     main: string;
     animation: string;
     theme: string;
-}
+}
+
+export type DependencyScopes = "compile" | "provided" | "runtime" | "test";