@e-mc/document 0.0.1

package/android/extensions/task/index.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const fs = require("fs");
+const child_process = require("child_process");
+const types_1 = require("../../../../types");
+const module_1 = require("../../../../module");
+async function finalize(instance) {
+    const commands = instance.config.commands;
+    if (!commands || this.archiving) {
+        return;
+    }
+    let taskArgs;
+    if (typeof commands === 'string') {
+        taskArgs = [[commands]];
+    }
+    else if ((0, types_1.isArray)(commands)) {
+        if (commands.every(value => typeof value === 'string')) {
+            taskArgs = [commands];
+        }
+        else {
+            taskArgs = commands.map(value => typeof value === 'string' ? [value] : value);
+        }
+    }
+    else {
+        return;
+    }
+    let { broadcastId, baseDirectory } = this, command = instance.settings.extensions?.task?.command, title, name, foundCwd;
+    if (command) {
+        if (command.indexOf('mvn') !== -1) {
+            title = 'maven';
+        }
+        else {
+            title = /([^\\/]+?)(?:\.[a-z]+)?$/i.exec(command)?.[1] || 'SPAWN';
+        }
+        command = path.normalize(command);
+        if (!command.includes(path.sep)) {
+            name = command;
+        }
+        command = module_1.default.sanitizeCmd(command);
+    }
+    else {
+        name = 'gradlew';
+        command = '.' + path.sep + name;
+        title = 'gradle';
+    }
+    if (name) {
+        try {
+            let appDir = baseDirectory;
+            while (!(foundCwd = fs.existsSync(path.join(appDir, name)))) {
+                const parent = path.dirname(appDir);
+                if (parent === appDir) {
+                    break;
+                }
+                appDir = parent;
+            }
+            if (foundCwd) {
+                baseDirectory = appDir;
+            }
+        }
+        catch {
+        }
+    }
+    for (const args of taskArgs) {
+        if (instance.aborted) {
+            return Promise.reject((0, types_1.createAbortError)());
+        }
+        const startTime = process.hrtime();
+        const task = args.join(' ');
+        await new Promise((resolve, reject) => {
+            this.formatMessage(4 /* LOG_TYPE.PROCESS */, title, ['Executing task...', task], baseDirectory);
+            let out = '', message = '';
+            const { stdout, stderr } = child_process.spawn(command, module_1.default.sanitizeArgs(args), { cwd: baseDirectory, shell: true, stdio: module_1.default.hasLogType(32768 /* LOG_TYPE.STDOUT */) && !broadcastId ? 'inherit' : undefined, signal: instance.signal })
+                .on('exit', code => {
+                if (!code) {
+                    instance.addLog(types_1.STATUS_TYPE.INFO, out);
+                    this.writeTimeProcess(title, 'Success -> ' + task, startTime);
+                    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));
+                }
+            })
+                .on('error', err => reject(err));
+            if (stdout) {
+                stdout.setEncoding('utf-8').on('data', (value) => {
+                    if (broadcastId) {
+                        this.formatMessage(types_1.STATUS_TYPE.INFO, '', value, null, { sessionId: '' });
+                    }
+                    out += value;
+                });
+            }
+            if (stderr) {
+                stderr.setEncoding('utf-8').on('data', (value) => {
+                    if (broadcastId) {
+                        this.formatMessage(types_1.STATUS_TYPE.ERROR, '', value, null, { sessionId: '' });
+                    }
+                    message += value;
+                });
+            }
+        })
+            .catch(err => instance.writeFail(["Unable to perform task" /* ERR_MESSAGE.PERFORM_TASK */, command + ' ' + task], err, { type: 4 /* LOG_TYPE.PROCESS */, startTime }));
+    }
+}
+exports.default = finalize;
+
+if (exports.default) {
+    module.exports = exports.default;
+    module.exports.default = exports.default;
+}

package/android/index.d.ts

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

package/android/index.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs = require("fs");
+const path = require("path");
+const types_1 = require("../../types");
+const index_1 = require("../index");
+class AndroidDocument extends index_1.default {
+    constructor() {
+        super(...arguments);
+        this.config = {
+            mainParentDir: 'app',
+            mainSrcDir: 'src/main',
+            mainActivityFile: '',
+            javaVersion: 0,
+            dataBinding: false,
+            projectName: undefined,
+            versionName: undefined,
+            versionCode: 0,
+            manifest: undefined,
+            namespace: undefined,
+            profileable: undefined,
+            dependencies: undefined,
+            commands: undefined
+        };
+        this.elements = [];
+        this.extensionData = {};
+        this._moduleName = 'android';
+        this._threadable = true;
+    }
+    static async finalize(instance) {
+        if (instance.aborted) {
+            return Promise.reject((0, types_1.createAbortError)());
+        }
+        if (instance.extensions.length) {
+            const config = instance.config;
+            const mainActivityFile = config.mainActivityFile;
+            if (mainActivityFile && !path.isAbsolute(mainActivityFile)) {
+                let pathname = /[\\/]/.test(mainActivityFile) && path.join(this.baseDirectory, mainActivityFile);
+                if (pathname && index_1.default.isPath(pathname)) {
+                    config.mainActivityFile = pathname;
+                }
+                else {
+                    const directories = [this.baseDirectory, config.mainParentDir, config.mainSrcDir];
+                    do {
+                        if (index_1.default.isPath(pathname = path.join(...directories.concat(mainActivityFile)))) {
+                            config.mainActivityFile = pathname;
+                            break;
+                        }
+                        directories.pop();
+                    } while (directories.length);
+                }
+            }
+        }
+        return super.finalize.call(this, instance);
+    }
+    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 target = this.config;
+            if (projectName) {
+                target.projectName = projectName;
+            }
+            if (namespace) {
+                target.namespace = namespace;
+            }
+            if (mainParentDir) {
+                target.mainParentDir = mainParentDir;
+            }
+            if (mainSrcDir) {
+                target.mainSrcDir = mainSrcDir;
+            }
+            if (mainActivityFile) {
+                target.mainActivityFile = mainActivityFile;
+            }
+            if (versionName) {
+                target.versionName = versionName;
+            }
+            if (manifest) {
+                target.manifest = manifest;
+            }
+            if (profileable !== undefined) {
+                target.profileable = profileable;
+            }
+            if (versionCode >= 1) {
+                target.versionCode = Math.min(Math.ceil(versionCode), 2100000000);
+            }
+            if (commands) {
+                target.commands = commands;
+            }
+            if (javaVersion) {
+                target.javaVersion = +(typeof javaVersion === 'string' ? javaVersion.toString().replace(/_/g, '.') : javaVersion);
+            }
+            if (dataBinding) {
+                target.dataBinding = true;
+            }
+            if ((0, types_1.isArray)(dependencies)) {
+                target.dependencies = dependencies;
+            }
+            if (targetAPI) {
+                this.targetAPI = targetAPI;
+            }
+            if ((0, types_1.isPlainObject)(directories)) {
+                this.directories = directories;
+            }
+            if ((0, types_1.isArray)(elements)) {
+                this.elements = elements;
+            }
+            if ((0, types_1.isPlainObject)(extensionData)) {
+                this.extensionData = extensionData;
+            }
+        }
+        return super.init(assets, config);
+    }
+    findVersion(name, fallback) {
+        const targetAPI = this.targetAPI;
+        if (targetAPI) {
+            if (!Array.isArray(name)) {
+                name = [name];
+            }
+            for (let i = 0; i < name.length; i += 2) {
+                name.splice(i, 0, name[i] + '-' + targetAPI);
+            }
+        }
+        return super.findVersion(name, fallback);
+    }
+    async using(data) {
+        if (this.aborted) {
+            return Promise.reject((0, types_1.createAbortError)());
+        }
+        const { host, file } = data;
+        const localUri = file.localUri;
+        switch (file.mimeType) {
+            case 'font/unknown':
+                switch (await host.findMime(file, true)) {
+                    case 'font/ttf':
+                    case 'font/otf':
+                        return;
+                    case 'font/woff':
+                    case 'font/woff2':
+                        break;
+                    default:
+                        host.deleteFile(localUri);
+                        return;
+                }
+            case 'font/woff':
+            case 'font/woff2': {
+                const instance = host.loadModule('compress');
+                const buffer = host.getBuffer(file);
+                if (instance && buffer) {
+                    await instance.tryFile(buffer, localUri, { format: 'ttf', etag: file.etag }, (err, result) => {
+                        if (err) {
+                            host.deleteFile(localUri);
+                            host.writeFail("Unable to compress file" /* ERR_MESSAGE.COMPRESS_FILE */, err, 8 /* LOG_TYPE.COMPRESS */);
+                        }
+                        else if ((0, types_1.isString)(result)) {
+                            host.replace(file, result);
+                        }
+                    });
+                }
+                break;
+            }
+        }
+    }
+    findTemplate(baseDir, filename, options) {
+        let detect, languageOf;
+        if (options) {
+            ({ detect, languageOf } = options);
+        }
+        let kotlin, language;
+        if (languageOf) {
+            kotlin = (language = this.settings.language?.[languageOf]) === 'kotlin';
+            const isKts = this.detectKts(baseDir, filename);
+            detect = isKts !== null && (kotlin && isKts || !kotlin && !isKts);
+            if (kotlin) {
+                filename += '.kts';
+            }
+        }
+        const localUri = path.join(baseDir, filename);
+        try {
+            const existing = detect && fs.existsSync(localUri);
+            const paths = language ? [language, filename] : [filename];
+            let uri;
+            if (!existing && !(uri = this.resolveDir('template', ...paths)) && !fs.existsSync(uri = path.join(__dirname, 'template', ...paths))) {
+                throw (0, types_1.errorValue)("File not found" /* ERR_MESSAGE.NOTFOUND_FILE */, uri);
+            }
+            return { localUri, source: fs.readFileSync(uri || localUri, 'utf-8'), existing, kotlin, language };
+        }
+        catch (err) {
+            this.writeFail(["Unable to read file" /* ERR_MESSAGE.READ_FILE */, path.basename(localUri)], err, 32 /* LOG_TYPE.FILE */);
+        }
+        return { kotlin, language };
+    }
+    detectKts(...paths) {
+        try {
+            const file = path.join(...paths);
+            if (fs.existsSync(file)) {
+                return false;
+            }
+            if (fs.existsSync(file + '.kts')) {
+                return true;
+            }
+        }
+        catch {
+        }
+        return null;
+    }
+    get settings() {
+        var _a;
+        return (_a = this.module).settings || (_a.settings = {});
+    }
+}
+exports.default = AndroidDocument;
+
+if (exports.default) {
+    module.exports = exports.default;
+    module.exports.default = exports.default;
+}

package/android/template/AndroidManifest.xml

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android" package="{{package}}">
+
+    <application
+        android:icon="@mipmap/ic_launcher"
+        android:label="{{label}}"
+        android:supportsRtl="{{supportsRtl}}"
+        android:theme="{{theme}}">
+        <activity
+            android:name="{{activityName}}"
+            android:exported="true"
+            android:label="{{label}}"
+            android:theme="{{theme}}">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+        <profileable android:shell="true" android:enabled="{{profileable}}" />
+    </application>
+
+</manifest>

package/android/template/java/build.gradle

@@ -0,0 +1,39 @@
+plugins {
+    id 'com.android.application'
+}
+
+android {
+    namespace ''
+    compileSdk 33
+
+    defaultConfig {
+        applicationId ''
+        minSdk 19
+        targetSdk 33
+        versionCode 1
+        versionName '1.0'
+
+        testInstrumentationRunner 'androidx.test.runner.AndroidJUnitRunner'
+    }
+    buildTypes {
+        release {
+            debuggable false
+            minifyEnabled true
+            shrinkResources false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+    buildFeatures {
+        viewBinding false
+    }
+}
+
+dependencies {
+    testImplementation 'junit:junit:4.13.2'
+    androidTestImplementation 'androidx.test.ext:junit:1.1.5'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'
+}

package/android/template/java/settings.gradle

@@ -0,0 +1,18 @@
+pluginManagement {
+    repositories {
+        gradlePluginPortal()
+        google()
+        mavenCentral()
+    }
+}
+
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+rootProject.name = '{{projectName}}'
+include '{{name}}'

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

@@ -0,0 +1,44 @@
+plugins {
+    id 'com.android.application'
+    id 'org.jetbrains.kotlin.android'
+}
+
+android {
+    namespace ''
+    compileSdk 33
+
+    defaultConfig {
+        applicationId ''
+        minSdk 19
+        targetSdk 33
+        versionCode 1
+        versionName '1.0'
+
+        testInstrumentationRunner 'androidx.test.runner.AndroidJUnitRunner'
+    }
+    buildTypes {
+        release {
+            debuggable false
+            minifyEnabled true
+            shrinkResources false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
+    }
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_1_8
+        targetCompatibility JavaVersion.VERSION_1_8
+    }
+    kotlinOptions {
+        jvmTarget = '1.8'
+    }
+    buildFeatures {
+        viewBinding false
+    }
+}
+
+dependencies {
+    implementation 'androidx.core:core-ktx:1.9.0'
+    testImplementation 'junit:junit:4.13.2'
+    androidTestImplementation 'androidx.test.ext:junit:1.1.5'
+    androidTestImplementation 'androidx.test.espresso:espresso-core:3.5.1'
+}

package/android/template/java+kotlin/settings.gradle

@@ -0,0 +1,18 @@
+pluginManagement {
+    repositories {
+        gradlePluginPortal()
+        google()
+        mavenCentral()
+    }
+}
+
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+rootProject.name = '{{projectName}}'
+include '{{name}}'

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

@@ -0,0 +1,46 @@
+plugins {
+    id("com.android.application")
+    kotlin("android")
+}
+
+android {
+    namespace = ""
+    compileSdk(33)
+
+    defaultConfig {
+        applicationId = ""
+        minSdk(19)
+        targetSdk(33)
+        versionCode = 1
+        versionName = "1.0"
+
+        testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner"
+    }
+    buildTypes {
+        getByName("release") {
+            isDebuggable = false
+            isMinifyEnabled = true
+            isShrinkResources = false
+            proguardFiles(getDefaultProguardFile("proguard-android.txt"), "proguard-rules.pro")
+        }
+    }
+    kotlinOptions {
+        jvmTarget = "1.8"
+    }
+    buildFeatures {
+        viewBinding = true
+    }
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_1_8
+    targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+dependencies {
+    implementation("org.jetbrains.kotlin:kotlin-stdlib:1.8.0")
+    implementation("androidx.core:core-ktx:1.9.0")
+    testImplementation("junit:junit:4.13.2")
+    androidTestImplementation("androidx.test.ext:junit:1.1.5")
+    androidTestImplementation("androidx.test.espresso:espresso-core:3.5.1")
+}

package/android/template/kotlin/settings.gradle.kts

@@ -0,0 +1,18 @@
+pluginManagement {
+    repositories {
+        gradlePluginPortal()
+        google()
+        mavenCentral()
+    }
+}
+
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        google()
+        mavenCentral()
+    }
+}
+
+rootProject.name = "${{projectName}}"
+include("{{name}}")

package/asset.d.ts

@@ -0,0 +1,8 @@
+import type { ExternalAsset } from '../types/lib/asset';
+
+declare namespace asset {
+    function isEqual(item: ExternalAsset, other: ExternalAsset): boolean;
+    function setInitialValue(file: ExternalAsset, cacheable?: boolean): void;
+}
+
+export = asset;

package/asset.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setInitialValue = exports.isEqual = void 0;
+function isEqual(item, other) {
+    return !!(item.id && item.id === other.id || item.uri === other.uri && item.pathname === other.pathname && item.filename === other.filename && item.pathname && item.filename);
+}
+exports.isEqual = isEqual;
+function setInitialValue(file, cacheable = true) {
+    file.initialValue || (file.initialValue = { pathname: file.pathname, filename: file.filename, mimeType: file.mimeType, localUri: file.localUri, inlineFilename: file.inlineFilename, cacheable });
+}
+exports.setInitialValue = setInitialValue;