@pi-r/android 0.12.4 → 0.13.0

package/extensions/gradle/dependencies/index.js

@@ -2,9 +2,10 @@
 
 const path = require('node:path');
 const fs = require('node:fs');
+const toml = require('toml');
 const Document = require('@e-mc/document');
 const { escapePattern, isArray, isString } = require('@e-mc/types');
-const { getIndent, getNewline, spliceString, trimQuote, wrapQuote } = require('@e-mc/document/util');
+const { getIndent, getNewline, spliceMatch, spliceString, splitEnclosing, trimQuote, wrapQuote } = require('@e-mc/document/util');
 const REGEXP_SEMVER = /^(?:(?:\s*,\s*)?(?:[([\]](?:(?:\s*,\s*)?\d+\.\d+(?:\s*,\s*)?)+[)[\]]|!!\d+\.\d+\.\d+|\d+\.\d+\.\d+!!))+$/;
 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}))?/g;
@@ -13,8 +14,7 @@ const REGEXP_LIBRARY = /([ \t]*)implementation\s+(?:(project|files)\(\s*("(?:[^"
 const REGEXP_LIBRARY_KOTLIN = /([ \t]*)implementation\(\s*(?:(project|files)\(\s*"(.+)"\s*\)|(fileTree)\(\s*mapOf\(((?:\s*"(?:dir|include)"\s+to\s+(?:"(?:[^"]|(?<=\\)")+"|listOf\([^)]+\))\s*,?){2})\)\s*\))\s*\)[ \t\r]*\n/g;
 const REGEXP_PLATFORM = /([ \t]*)implementation\s+platform\(\s*("(?:[^"]|(?<=\\)")+"|'(?:[^']|(?<=\\)')+')\s*\)[ \t\r]*\n/g;
 const REGEXP_PLATFORM_KOTLIN = /([ \t]*)implementation\(\s*platform\(\s*"(.+)"\s*\)\s*\)[ \t\r]*\n/g;
-const REGEXP_VERSIONS = /(\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;
+const REGEXP_VERSIONS_ATTR = /\b(group|name|module|version(?:\.ref)?)\s*=\s*(?:"([^"]+)"|'([^']+)'|(\{[^}]+\}))/gd;
 function isUpgrade(version, pending) {
     if (isSemVer(pending)) {
         return true;
@@ -99,6 +99,21 @@ function writeMethod(kotlin, named, item, args = '', prefix = 'implementation')
     }
     return prefix + dependency;
 }
+function compareFileTree(from, orig) {
+    try {
+        return isArray(from) && from.sort().toString() === JSON.parse(`[${orig}]`).sort().toString();
+    }
+    catch {
+        return false;
+    }
+}
+function removeGroup(items, id) {
+    for (let i = 0; i < items.length; ++i) {
+        if (items[i][0] === id) {
+            items.splice(i--, 1);
+        }
+    }
+}
 function valueFor(name, value, kotlin, quote = false) {
     value = value.toString();
     const q = quote ? kotlin && !value.includes('"') || value.includes("'") ? '"' : "'" : '';
@@ -107,8 +122,8 @@ function valueFor(name, value, kotlin, quote = false) {
 const isLatest = (value) => value === '' || value.startsWith('latest.');
 const isSemVer = (value) => isLatest(value) || REGEXP_SEMVER.test(value);
 const updateOpts = (updateOnly = false) => ({ upgrade: true, updateOnly });
-const writeOutput = (match, source, value) => spliceString(source, match.index, match.index + match[0].length, value);
 const toCamelCase = (value) => value.replace(/-([a-z])/gi, (...capture) => capture[1].toUpperCase());
+const createBoundary = (name) => new RegExp(`(?<=^|\\n[ \\t]*)\\[${name}\\]\\s*`);
 function finalize(instance) {
     const { profileable, dependencies, libraries, dataBinding, jvmToolchain, versionName, versionCode, namespace, applicationId, mainParentDir } = instance.config;
     if (!profileable && !dependencies && !libraries && !dataBinding && !jvmToolchain && !versionName && !versionCode && !namespace && !applicationId) {
@@ -128,7 +143,7 @@ function finalize(instance) {
         };
         const setDependencies = (match, output) => {
             if (modified || !existing) {
-                setModified(spliceString(source, match.index, match.index + match[0].length, `dependencies {${output}}`));
+                setModified(spliceMatch(source, match, `dependencies {${output}}`));
             }
         };
         if (dependencies) {
@@ -243,80 +258,101 @@ function finalize(instance) {
                 const newLine = getNewline(source);
                 const gradleDir = path.join(this.baseDirectory, 'gradle');
                 const template = instance.findTemplate(gradleDir, "libs.versions.toml", { detect: true, subDir: language, throwsDoesNotExist: false });
-                const removeGroup = (id) => {
-                    for (let i = 0; i < items.length; ++i) {
-                        if (items[i][0] === id) {
-                            items.splice(i--, 1);
-                        }
-                    }
-                };
                 let content = match[1], named = false, versioning = false, indent;
                 for (const platform of content.matchAll(kotlin ? REGEXP_PLATFORM_KOTLIN : REGEXP_PLATFORM)) {
                     const [group, name] = trimQuote(platform[1]).trim().split(':');
                     if (name.endsWith('-bom')) {
-                        removeGroup(group);
+                        removeGroup(items, group);
                     }
                 }
-                if (template.source && template.localUri && instance.canWrite(template.localUri, { ownPermissionOnly: true })) {
-                    versioning = kotlin && versionCatalog !== false || !!versionCatalog;
-                    if (versioning || template.existing) {
-                        const libs = {};
-                        const versions = {};
-                        let config = template.source, catalog;
-                        for (const ref of config.matchAll(REGEXP_VERSIONS)) {
-                            versions[ref[1]] = (ref[2] || ref[3]).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(':');
+                if (template.source && template.localUri && instance.canWrite(template.localUri, { ownPermissionOnly: true }) && (versioning = kotlin && versionCatalog !== false || !!versionCatalog)) {
+                    const libs = {};
+                    try {
+                        let config = template.source;
+                        const { versions = {}, libraries: packages = {} } = toml.parse(config);
+                        if (Object.keys(packages).length > 0) {
+                            const locations = ['versions', 'plugins', 'libraries'].map(name => createBoundary(name).exec(config)?.index ?? NaN).filter(value => !isNaN(value));
+                            const lowerBound = locations.pop();
+                            let upperBound = Infinity;
+                            if (Math.min(lowerBound, ...locations) === lowerBound) {
+                                upperBound = Math.min(...locations);
                             }
-                            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];
+                            else if (Math.max(lowerBound, ...locations) !== lowerBound) {
+                                upperBound = Math.max(...locations);
+                            }
+                            for (const key in packages) {
+                                const pattern = new RegExp(`(\\n[ \\t]*${escapePattern(key)})\\s*=\\s*(?:(["'])(.+)\\2|\\{)`, 'gd');
+                                pattern.lastIndex = lowerBound;
+                                const catalog = pattern.exec(config);
+                                const indices = catalog?.indices;
+                                if (indices && catalog.index < upperBound) {
+                                    const lib = {};
+                                    let position;
+                                    if (catalog[3]) {
+                                        let version;
+                                        [lib.group, lib.name, version] = catalog[3].trim().split(':');
+                                        if (version && /^\d+\.\d+\.\d+$/.test(version) && (position = indices[3])) {
+                                            const start = position[0] + catalog[3].indexOf(version);
+                                            lib.version = version;
+                                            lib.version_indices = [start, start + version.length];
                                         }
                                     }
-                                }
-                            }
-                            let { group, name } = lib;
-                            if (lib.module) {
-                                [group, name] = lib.module.split(':');
-                            }
-                            if (group && name) {
-                                if (name.endsWith('-bom')) {
-                                    removeGroup(group);
-                                    continue;
-                                }
-                                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) {
-                                            if (versions[ref] !== item[2]) {
-                                                const target = new RegExp(`\\s${escapePattern(ref)}\\s*=\\s*(?:"([^"]+)"|'([^']+)')`, 'd').exec(config);
-                                                const indices = target?.indices;
-                                                if (indices) {
-                                                    const [start, end] = indices[1] || indices[2];
-                                                    config = spliceString(config, start, end, versions[ref] = item[2], REGEXP_VERSIONS_LIB);
+                                    else if (position = indices[1]) {
+                                        let start = position[1];
+                                        const [first, second] = splitEnclosing(config.slice(start), ['{', '}'], 1);
+                                        if (second.at(-1) === '}') {
+                                            let attr, i = 0;
+                                            while (attr = REGEXP_VERSIONS_ATTR.exec(second)) {
+                                                lib[attr[1]] = (attr[i = 2] || attr[i = 3] || attr[i = -1]).trim();
+                                                if (attr[1] === 'version' && (position = attr.indices?.[i])) {
+                                                    start += first.length;
+                                                    lib.version_indices = position.map(pos => start + pos);
                                                 }
                                             }
+                                            REGEXP_VERSIONS_ATTR.lastIndex = 0;
+                                        }
+                                        else {
+                                            continue;
                                         }
-                                        else if (lib.version_indices) {
-                                            const [start, end] = lib.version_indices;
-                                            config = spliceString(config, start, end, lib.version = item[2], REGEXP_VERSIONS_LIB);
+                                    }
+                                    let { group, name } = lib;
+                                    if (lib.module) {
+                                        [group, name] = lib.module.split(':');
+                                    }
+                                    if (group && name) {
+                                        if (name.endsWith('-bom')) {
+                                            removeGroup(items, group);
+                                        }
+                                        else {
+                                            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 (isString(version) && checkVersion(item, version)) {
+                                                    if (ref) {
+                                                        if (versions[ref] !== item[2]) {
+                                                            const target = new RegExp(`\\n[ \\t]*${escapePattern(ref)}\\s*=\\s*(?:"([^"]+)"|'([^']+)')`, 'd').exec(config);
+                                                            const found = target?.indices;
+                                                            if (found) {
+                                                                const [start, end] = found[1] || found[2];
+                                                                config = spliceString(config, start, end, item[2]);
+                                                                versions[ref] = item[2];
+                                                            }
+                                                        }
+                                                    }
+                                                    else if (lib.version_indices) {
+                                                        const [start, end] = lib.version_indices;
+                                                        config = spliceString(config, start, end, item[2]);
+                                                        lib.version = item[2];
+                                                    }
+                                                }
+                                            }
+                                            libs[key] = lib;
                                         }
                                     }
                                 }
-                                libs[catalog[1]] = lib;
                             }
                         }
                         if (versioning && items.length > 0) {
@@ -361,30 +397,26 @@ function finalize(instance) {
                                 item[2] = '';
                                 libs[key] = { group, name, "version.ref": versionRef };
                             }
-                            const lib = /\[libraries\]\s*/.exec(config);
+                            const lib = createBoundary('libraries').exec(config);
                             if (lib) {
-                                config = writeOutput(lib, config, output);
+                                config = spliceMatch(config, lib, output);
                             }
                             else {
                                 config += (config.endsWith(newLine) ? '' : newLine) + output;
                             }
                             if (outputVer) {
                                 outputVer = '[versions]' + newLine + outputVer;
-                                const ver = /\[versions\]\s*/.exec(config);
-                                config = ver ? writeOutput(ver, config, outputVer) : outputVer + newLine + config;
+                                const ver = createBoundary('versions').exec(config);
+                                config = ver ? spliceMatch(config, ver, outputVer) : outputVer + newLine + config;
                             }
-                            REGEXP_VERSIONS.lastIndex = 0;
                         }
                         if (Document.createDir(gradleDir)) {
-                            try {
-                                fs.writeFileSync(template.localUri, config, 'utf8');
-                                this.add(template.localUri);
-                            }
-                            catch (err) {
-                                this.writeFail(["Unable to write file", path.basename(template.localUri)], err, 32);
-                            }
+                            fs.writeFileSync(template.localUri, config, 'utf8');
+                            this.add(template.localUri);
                         }
-                        REGEXP_VERSIONS_LIB.lastIndex = 0;
+                    }
+                    catch (err) {
+                        this.writeFail([Object.keys(libs).length > 0 ? "Unable to write file" : "Unable to load configuration", path.basename(template.localUri)], err, 32);
                     }
                 }
                 if (items.length > 0) {
@@ -429,7 +461,7 @@ function finalize(instance) {
                                         version = '';
                                     }
                                     if (checkVersion(item, version, method[0])) {
-                                        content = spliceString(content, method.index, method.index + method[0].length, method[1] + writeMethod(kotlin, named, item, method[4], method[2]) + newLine, pattern);
+                                        content = spliceMatch(content, method, method[1] + writeMethod(kotlin, named, item, method[4], method[2]) + newLine, pattern);
                                         modified = true;
                                     }
                                 }
@@ -469,19 +501,11 @@ function finalize(instance) {
                             }
                             case 'fileTree': {
                                 const dir = (kotlin ? /"dir"\s+to\s+"(.+)"(?:\s*,|$)/ : /\bdir\s*:\s*["'](.+)["'](?:\s*,|$)/).exec(match[5])?.[1];
-                                const include = (kotlin ? /"include"\s+to\s+listOf\(([^)]+)\)(?:\s*,|$)/ : /\binclude\s*:\s*\[(.+)\](?:\s*,|$)/).exec(match[5])?.[1];
+                                const include = (kotlin ? /"include"\s+to\s+listOf\(([^)]+)\)(?:\s*,|$)/ : /\binclude\s*:\s*\[([^\]]+)\](?:\s*,|$)/).exec(match[5])?.[1];
                                 if (dir && include) {
-                                    const compare = (from, orig) => {
-                                        try {
-                                            return isArray(from) && from.sort().toString() === JSON.parse(`[${orig}]`).sort().toString();
-                                        }
-                                        catch {
-                                            return false;
-                                        }
-                                    };
                                     const target = libraries[attr];
                                     for (let i = 0; i < target.length; ++i) {
-                                        if (target[i].dir === dir && compare(target[i].include, include)) {
+                                        if (target[i].dir === dir && compareFileTree(target[i].include, include)) {
                                             index = i;
                                             break;
                                         }
@@ -645,7 +669,7 @@ function finalize(instance) {
                     fs.readdirSync(subDir, { withFileTypes: true }).forEach(item => {
                         const srcName = path.join(subDir, item.name);
                         if (item.isDirectory()) {
-                            switch (/^\$\{([^}]+)\}$/.exec(item.name)?.[1]) {
+                            switch (/^\$\{(.+)\}$/.exec(item.name)?.[1]) {
                                 case 'app':
                                     if (instance.config.mainParentDir) {
                                         recurse.call(this, srcName, path.join(targetDir, instance.config.mainParentDir));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-r/android",
-  "version": "0.12.4",
+  "version": "0.13.0",
   "description": "Android document constructor for E-mc.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -17,12 +17,13 @@
   "license": "MIT",
   "homepage": "https://github.com/anpham6/pi-r#readme",
   "dependencies": {
-    "@e-mc/document": "^0.14.5",
-    "@e-mc/types": "^0.14.5",
+    "@e-mc/document": "^0.14.6",
+    "@e-mc/types": "^0.14.6",
     "dom-serializer": "^2.0.0",
     "domhandler": "^5.0.3",
     "domutils": "^3.2.2",
     "htmlparser2": "^10.1.0",
+    "toml": "^4.3.0",
     "which": "^4.0.0"
   }
 }

package/project/gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.5.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.6.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

package/template/java/static/build.gradle

@@ -1,4 +1,4 @@
 plugins {
-    id 'com.android.application' version '9.2.1' apply false
-    id 'com.android.library' version '9.2.1' apply false
+    id 'com.android.application' version '9.3.2' apply false
+    id 'com.android.library' version '9.3.2' apply false
 }

package/template/java+kotlin/build.gradle

@@ -7,7 +7,7 @@ android {
     namespace = ''
     compileSdk {
         version = release(37) {
-            minorApiLevel = 0
+            minorApiLevel = 1
         }
     }
 

package/template/java+kotlin/libs.versions.toml

@@ -1,7 +1,7 @@
 [versions]
-agp = "9.2.1"
+agp = "9.3.2"
 coreKtx = "1.19.0"
-kotlin = "2.4.0"
+kotlin = "2.4.10"
 junit = "4.13.2"
 junitVersion = "1.3.0"
 espressoCore = "3.7.0"

package/template/kotlin/build.gradle.kts

@@ -1,13 +1,14 @@
 plugins {
     alias(libs.plugins.android.application)
     alias(libs.plugins.kotlin.compose)
+    alias(libs.plugins.google.devtools.ksp)
 }
 
 android {
     namespace = ""
     compileSdk {
         version = release(37) {
-            minorApiLevel = 0
+            minorApiLevel = 1
         }
     }
 
@@ -43,6 +44,7 @@ android {
 dependencies {
     implementation(libs.jetbrains.kotlin)
     implementation(libs.androidx.core.ktx)
+    implementation(libs.androidx.navigation.fragment.ktx)
     implementation(libs.androidx.appcompat)
     implementation(libs.androidx.constraintlayout)
     implementation(libs.android.material)

package/template/kotlin/libs.versions.toml

@@ -1,17 +1,21 @@
 [versions]
-agp = "9.2.1"
+agp = "9.3.2"
 coreKtx = "1.19.0"
-kotlin = "2.4.0"
+navigationFragmentKtx = "2.10.0"
+kotlin = "2.4.10"
+ksp = "2.3.11"
 junit = "4.13.2"
 junitVersion = "1.3.0"
 espressoCore = "3.7.0"
-appcompat = "1.7.1"
+appcompat = "1.8.0"
 material = "1.14.0"
-constraintlayout = "2.2.1"
+constraintlayout = "2.2.2"
 
 [libraries]
 androidx-core-ktx = { group = "androidx.core", name = "core-ktx", version.ref = "coreKtx" }
+androidx-navigation-fragment-ktx = { group = "androidx.navigation", name = "navigation-fragment-ktx", version.ref = "navigationFragmentKtx" }
 jetbrains-kotlin = { group = "org.jetbrains.kotlin", name = "kotlin-stdlib", version.ref = "kotlin" }
+google-devtools-ksp = { id = "com.google.devtools.ksp", version.ref = "ksp" }
 junit = { group = "junit", name = "junit", version.ref = "junit" }
 androidx-junit = { group = "androidx.test.ext", name = "junit", version.ref = "junitVersion" }
 androidx-espresso-core = { group = "androidx.test.espresso", name = "espresso-core", version.ref = "espressoCore" }

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

@@ -2,4 +2,5 @@ plugins {
     alias(libs.plugins.android.application) apply false
     alias(libs.plugins.kotlin.android) apply false
     alias(libs.plugins.kotlin.compose) apply false
+    alias(libs.plugins.google.devtools.ksp) apply false
 }