@e-mc/document 0.0.1

package/LICENSE

@@ -0,0 +1,11 @@
+Copyright 2023 An Pham
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,5 @@
+### @e-mc/document
+
+### LICENSE
+
+BSD 3-Clause

package/android/document.d.ts

@@ -0,0 +1,66 @@
+import type { FinalizedElement } from '../../types/lib/squared';
+import type { DocumentOutput } from '../../types/lib/android';
+
+import type { DocumentConstructor, IDocument, IFileManager } from '../../types/lib';
+import type { ExternalAsset } from '../../types/lib/asset';
+import type { DocumentDirectory as IDocumentDirectory, DocumentModule as IDocumentModule } from '../../types/lib/settings';
+
+interface DocumentDirectory extends IDocumentDirectory {
+    template?: string;
+}
+
+interface AndroidDocumentSettings extends PlainObject {
+    extensions?: {
+        task?: {
+            command?: string;
+        };
+    };
+    language?: {
+        gradle?: "java" | "kotlin" | "java+kotlin";
+    };
+    directory?: DocumentDirectory;
+}
+
+type LanguageType = "gradle";
+type DocumentProperties = "targetAPI" | "elements" | "extensionData" | "directories";
+
+export interface UserConfig extends Omit<DocumentOutput, DocumentProperties> {
+    mainParentDir: string;
+    mainSrcDir: string;
+    mainActivityFile: string;
+    javaVersion: number;
+    dataBinding: boolean;
+}
+
+export interface DocumentModule extends IDocumentModule {
+    settings?: AndroidDocumentSettings;
+}
+
+export interface TemplateData {
+    localUri?: string;
+    source?: string;
+    existing?: boolean;
+    kotlin?: boolean;
+    language?: string;
+}
+
+export interface FindTemplateOptions {
+    detect?: boolean;
+    languageOf?: LanguageType;
+}
+
+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;
+    detectKts(...paths: string[]): Null<boolean>;
+    get settings(): AndroidDocumentSettings;
+}
+
+export interface AndroidDocumentConstructor<T extends IFileManager<U>, U extends DocumentAsset = DocumentAsset> extends DocumentConstructor<T, U> {
+    readonly prototype: IAndroidDocument<T, U>;
+    new(module?: DocumentModule, ...args: unknown[]): IAndroidDocument<T, U>;
+}
+
+export type DocumentAsset = ExternalAsset;

package/android/extensions/app/manifest/index.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const htmlparser2 = require("htmlparser2");
+const domhandler = require("domhandler");
+const domutils = require("domutils");
+const domserializer = require("dom-serializer");
+const util_1 = require("../../../../util");
+const types_1 = require("../../../../../types");
+const Parser = htmlparser2.Parser;
+const DomHandler = domhandler.DomHandler;
+function finalize(instance) {
+    const config = instance.config;
+    if (!config.manifest) {
+        return;
+    }
+    let { localUri, source, existing } = instance.findTemplate(path.join(this.baseDirectory, config.mainParentDir, config.mainSrcDir), "AndroidManifest.xml" /* MANIFEST.FILENAME */, { detect: !this.archiving });
+    if (localUri && source && instance.canWrite(localUri, { ownPermissionOnly: true })) {
+        const { package: manifestPackage, application = {} } = config.manifest;
+        const { supportsRtl, label, theme, activity, metaData = [], activityName, fontProvider } = application;
+        const profileable = config.profileable;
+        let modified;
+        if (!existing) {
+            source = (0, util_1.replaceAll)(source.replace(manifestPackage ? '{{package}}' : ' package="{{package}}"', manifestPackage || ''), (name) => {
+                switch (name) {
+                    case 'supportsRtl':
+                        return supportsRtl === false ? 'false' : 'true';
+                    case 'label':
+                        return '@string/' + (label || 'app_name');
+                    case 'theme':
+                        return theme ? '@style/' + theme : '';
+                    case 'activityName':
+                        return activityName || '';
+                    case 'profileable':
+                        return profileable ? 'true' : 'false';
+                    default:
+                        return '';
+                }
+            });
+        }
+        else if (manifestPackage || theme || activityName || activity || supportsRtl !== undefined) {
+            new Parser(new DomHandler((err, dom) => {
+                if (err) {
+                    instance.writeFail(['Unable to parse XML document', "AndroidManifest.xml" /* MANIFEST.FILENAME */], err, 0 /* LOG_TYPE.UNKNOWN */);
+                    return;
+                }
+                let target = null;
+                if (manifestPackage && (target = domutils.findOne(elem => elem.tagName === 'manifest', dom, true))) {
+                    target.attribs['package'] = manifestPackage;
+                    modified = true;
+                }
+                if (target = domutils.findOne(elem => elem.tagName === 'application', dom, true)) {
+                    if (label) {
+                        target.attribs['android:label'] = '@string/' + label;
+                        modified = true;
+                    }
+                    if (theme) {
+                        target.attribs['android:theme'] = '@style/' + theme;
+                        modified = true;
+                    }
+                    if (supportsRtl !== undefined) {
+                        target.attribs['android:supportsRtl'] = supportsRtl.toString();
+                        modified = true;
+                    }
+                    if (activityName || activity) {
+                        const activities = domutils.getElementsByTagName('activity', target, true);
+                        if (activityName) {
+                            for (const item of activities) {
+                                const intentFilter = domutils.findAll(elem => elem.tagName === 'intent-filter', [item]);
+                                if (intentFilter.length) {
+                                    const action = domutils.findOne(elem => elem.tagName === 'action' && elem.attribs['android:name'] === 'android.intent.action.MAIN', intentFilter);
+                                    if (action) {
+                                        const attribs = item.attribs;
+                                        attribs['android:name'] = activityName;
+                                        attribs['android:exported'] = 'true';
+                                        modified = true;
+                                        break;
+                                    }
+                                }
+                            }
+                        }
+                        if (activity) {
+                            for (const name in activity) {
+                                const { layout: attribs } = activity[name];
+                                if (attribs) {
+                                    let element = domutils.findOne(elem => elem.attribs['android:name'] === name, activities);
+                                    if (!element) {
+                                        domutils.appendChild(target, element = new domhandler.Element('activity', { 'android:name': name }));
+                                        domutils.append(element, new domhandler.Text('\n'));
+                                    }
+                                    let layout = domutils.findOne(elem => elem.tagName === 'layout', [element]), found = true;
+                                    if (!layout) {
+                                        domutils.appendChild(element, layout = new domhandler.Element('layout', {}));
+                                        domutils.append(layout, new domhandler.Text('\n'));
+                                        found = false;
+                                    }
+                                    for (const attr in attribs) {
+                                        switch (attr) {
+                                            case 'defaultHeight':
+                                            case 'defaultWidth':
+                                            case 'minHeight':
+                                            case 'minWidth':
+                                            case 'gravity': {
+                                                const value = attribs[attr];
+                                                if (!found || layout.attribs['android:' + attr] !== value) {
+                                                    layout.attribs['android:' + attr] = value;
+                                                    modified = true;
+                                                }
+                                                break;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    if (profileable !== undefined) {
+                        const attribs = profileable ? { 'android:shell': 'true', 'android:enabled': 'true' } : { 'android:enabled': 'false' };
+                        const element = domutils.findOne(elem => elem.tagName === 'profileable', [target]);
+                        if (element) {
+                            Object.assign(element.attribs, attribs);
+                        }
+                        else if (profileable) {
+                            domutils.appendChild(target, new domhandler.Element('profileable', attribs));
+                            domutils.appendChild(target, new domhandler.Text('\n'));
+                        }
+                        modified = true;
+                    }
+                    if (modified) {
+                        source = domserializer.default(dom, { xmlMode: true });
+                    }
+                }
+            }), { xmlMode: true, decodeEntities: false }).end(source);
+        }
+        if (fontProvider) {
+            metaData.push({ name: 'preloaded_fonts', resource: '@array/' + fontProvider });
+        }
+        if ((0, types_1.isArray)(metaData)) {
+            new Parser(new DomHandler((err, dom) => {
+                if (err) {
+                    instance.writeFail(['Unable to parse XML document', "AndroidManifest.xml" /* MANIFEST.FILENAME */], err, 0 /* LOG_TYPE.UNKNOWN */);
+                    return;
+                }
+                const app = domutils.findOne(elem => elem.tagName === 'application', dom, true);
+                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;
+                        }
+                    }
+                }
+            }), { xmlMode: true, decodeEntities: false }).end(source);
+        }
+        if (modified || !existing) {
+            try {
+                if (instance.writeFile(localUri, source, { encoding: 'utf-8', ownPermissionOnly: true, throwsPermission: true }) && !existing) {
+                    this.add(localUri);
+                }
+            }
+            catch (err) {
+                this.writeFail(["Unable to write file" /* ERR_MESSAGE.WRITE_FILE */, path.basename(localUri)], err, 8192 /* LOG_TYPE.PERMISSION */);
+            }
+        }
+    }
+}
+exports.default = finalize;
+
+if (exports.default) {
+    module.exports = exports.default;
+    module.exports.default = exports.default;
+}

package/android/extensions/gradle/dependencies/index.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const util_1 = require("../../../../util");
+const types_1 = require("../../../../../types");
+const index_1 = require("../../../../index");
+function finalize(instance) {
+    const config = instance.config;
+    const { profileable, dependencies, dataBinding, versionName, versionCode } = config;
+    if (!profileable && !dependencies && !dataBinding && !versionName && !versionCode && !config.namespace) {
+        return;
+    }
+    let { localUri, source, existing, kotlin } = instance.findTemplate(path.join(this.baseDirectory, config.mainParentDir), 'build.gradle', { detect: !this.archiving, languageOf: 'gradle' });
+    if (localUri && source && instance.canWrite(localUri, { ownPermissionOnly: true })) {
+        let { namespace, javaVersion } = config, jvmTarget, modified;
+        const upgrade = javaVersion > 0;
+        const setModified = (output) => {
+            if (output !== source) {
+                source = output;
+                modified = true;
+            }
+        };
+        if (dependencies) {
+            const items = dependencies.map(item => item.split(':'));
+            if (!kotlin && items.some(value => value[1].endsWith('-ktx'))) {
+                setModified(index_1.default.updateGradle(source, ['plugins'], "id 'kotlin-android'", { multiple: true }));
+            }
+            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])) {
+                    let group, name, version;
+                    if (impl[2]) {
+                        [group, name, version] = impl[2].trim().split(/\s*:\s*/);
+                    }
+                    else if (impl[3]) {
+                        const method = /(group|name|version)\s*:\s*["']([^"']+)["']/g;
+                        let param;
+                        while (param = method.exec(impl[3])) {
+                            const value = param[2].trim();
+                            switch (param[1]) {
+                                case 'group':
+                                    group = value;
+                                    break;
+                                case 'name':
+                                    name = value;
+                                    break;
+                                case 'version':
+                                    version = value;
+                                    break;
+                            }
+                        }
+                    }
+                    if (group && name) {
+                        let found = 0, index = -1;
+                        if (version) {
+                            index = items.findIndex(seg => seg[0] === group && seg[1] === name);
+                            if (index !== -1) {
+                                found = 1;
+                                if (version[0] !== '$' || !kotlin && impl[0].indexOf("'") !== -1) {
+                                    const current = items[index][2].split('.').map(seg => +seg);
+                                    const parts = version.split('.');
+                                    for (let i = 0, value; i < parts.length; ++i) {
+                                        if (isNaN(value = +parts[i]) || +current[i] > value) {
+                                            found = 2;
+                                            break;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        if (found) {
+                            if (found === 2) {
+                                content = content.replace(impl[0].trim(), writeImpl(items[index]));
+                                modified = true;
+                            }
+                            items.splice(index, 1);
+                        }
+                    }
+                    if (impl[1]) {
+                        indent = impl[1];
+                    }
+                }
+                if (items.length) {
+                    indent || (indent = (0, util_1.getIndent)(source));
+                    content = items.reduce((a, b) => a + indent + writeImpl(b) + '\n', 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')) {
+                let output = source;
+                if (kotlin) {
+                    output = index_1.default.updateGradle(output, ['plugins'], 'kotlin("android")');
+                    output = index_1.default.updateGradle(output, ['android', 'buildFeatures'], 'compose = true');
+                }
+                else {
+                    output = index_1.default.updateGradle(output, ['plugins'], "id 'org.jetbrains.kotlin.android'", { upgrade: true, multiple: true, addendum: `version '${instance.findVersion('org.jetbrains.kotlin:kotlin-stdlib', "1.8.10" /* VERSIONS.KOTLIN_STDLIB */)}'` });
+                    output = index_1.default.updateGradle(output, ['android', 'buildFeatures'], "compose true");
+                    output = index_1.default.updateGradle(output, ['android', 'composeOptions'], `kotlinCompilerExtensionVersion '${instance.findVersion('kotlinCompilerExtensionVersion', "1.4.3" /* VERSIONS.KOTLIN_COMPILER */)}'`, true);
+                    if (upgrade) {
+                        output = index_1.default.updateGradle(output, ['android', 'kotlinOptions'], `jvmTarget = '${javaVersion}'`, true);
+                    }
+                    else {
+                        output = index_1.default.updateGradle(output, ['android', 'kotlinOptions'], "jvmTarget = '1.8'");
+                        jvmTarget = '1_8';
+                    }
+                }
+                setModified(output);
+            }
+        }
+        if (upgrade || jvmTarget) {
+            const compatibility = 'JavaVersion.VERSION_' + (upgrade ? javaVersion.toString().replace(/\./g, '_') : jvmTarget);
+            let output = source;
+            if (kotlin) {
+                output = index_1.default.updateGradle(output, ['java'], 'sourceCompatibility = ' + compatibility, upgrade);
+                output = index_1.default.updateGradle(output, ['java'], 'targetCompatibility = ' + compatibility, upgrade);
+                output = index_1.default.updateGradle(output, ['android', 'kotlinOptions'], `jvmTarget = "${javaVersion}"`, upgrade);
+            }
+            else {
+                output = index_1.default.updateGradle(output, ['android', 'compileOptions'], 'sourceCompatibility ' + compatibility, upgrade);
+                output = index_1.default.updateGradle(output, ['android', 'compileOptions'], 'targetCompatibility ' + compatibility, upgrade);
+            }
+            setModified(output);
+        }
+        if (!existing) {
+            const targetAPI = instance.targetAPI;
+            let output = source;
+            if (targetAPI) {
+                const values = typeof targetAPI === 'string' ? [`"android-${targetAPI}"`, `"${targetAPI}"`] : [targetAPI, targetAPI];
+                const updateOnly = +targetAPI >= 31;
+                let revised = index_1.default.updateGradle(output, ['android'], kotlin ? `compileSdkVersion(${values[0]})` : 'compileSdkVersion ' + values[0], { upgrade: true, updateOnly });
+                if (revised === output) {
+                    output = index_1.default.updateGradle(output, ['android'], kotlin ? `compileSdk(${values[0]})` : 'compileSdk ' + values[0], true);
+                }
+                else {
+                    output = revised;
+                }
+                revised = index_1.default.updateGradle(output, ['android', 'defaultConfig'], kotlin ? `targetSdkVersion(${values[1]})` : 'targetSdkVersion ' + values[1], { upgrade: true, updateOnly });
+                if (revised === output) {
+                    output = index_1.default.updateGradle(output, ['android', 'defaultConfig'], kotlin ? `targetSdk(${values[1]})` : 'targetSdk ' + values[1], true);
+                }
+                else {
+                    output = revised;
+                }
+                const version = instance.findVersion('buildToolsVersion');
+                if (version) {
+                    output = index_1.default.updateGradle(output, ['android'], kotlin ? `buildToolsVersion = "${version}"` : `buildToolsVersion "${version}"`, true);
+                }
+            }
+            if (namespace || (namespace = config.manifest?.package)) {
+                output = index_1.default.updateGradle(output, ['android', 'defaultConfig'], (kotlin ? 'applicationId = ' : 'applicationId ') + `"${namespace}"`, true);
+            }
+            setModified(output);
+        }
+        if (dataBinding) {
+            setModified(index_1.default.updateGradle(source, ['android', 'buildFeatures'], kotlin ? 'dataBinding = true' : 'dataBinding true', true));
+        }
+        if (namespace) {
+            setModified(index_1.default.updateGradle(source, ['android'], (kotlin ? 'namespace = ' : 'namespace ') + `"${namespace}"`, true));
+        }
+        if (profileable) {
+            let name, items;
+            if (Array.isArray(profileable)) {
+                if (profileable.length && !profileable[0].startsWith('--')) {
+                    name = profileable.shift();
+                }
+                items = profileable;
+            }
+            else if (typeof profileable === 'string') {
+                if (profileable.startsWith('--')) {
+                    items = [profileable];
+                }
+                else {
+                    name = profileable;
+                }
+            }
+            name || (name = 'debug');
+            setModified(index_1.default.updateGradle(source, ['android', 'buildTypes', kotlin ? 'getByName("release")' : 'release'], 'signingConfig ' + (kotlin ? `= signingConfigs.getByName("${name}")` : 'signingConfigs.' + name), true));
+            if ((0, types_1.isArray)(items)) {
+                const parameters = items.map(value => `"${value}"`).join(', ');
+                setModified(index_1.default.updateGradle(source, ['android', 'aaptOptions'], 'additionalParameters ' + (kotlin ? `= [${parameters}]` : parameters), true));
+            }
+        }
+        if (versionName) {
+            setModified(index_1.default.updateGradle(source, ['android', 'defaultConfig'], (kotlin ? 'versionName = ' : 'versionName ') + `"${versionName}"`, true));
+        }
+        if (versionCode) {
+            setModified(index_1.default.updateGradle(source, ['android', 'defaultConfig'], (kotlin ? 'versionCode = ' : 'versionCode ') + versionCode, true));
+        }
+        if (modified || !existing) {
+            try {
+                if (instance.writeFile(localUri, source, { encoding: 'utf-8', ownPermissionOnly: true, throwsPermission: true }) && !existing) {
+                    this.add(localUri);
+                }
+            }
+            catch (err) {
+                this.writeFail(["Unable to write file" /* ERR_MESSAGE.WRITE_FILE */, path.basename(localUri)], err, 8192 /* LOG_TYPE.PERMISSION */);
+            }
+        }
+    }
+}
+exports.default = finalize;
+
+if (exports.default) {
+    module.exports = exports.default;
+    module.exports.default = exports.default;
+}

package/android/extensions/gradle/settings/index.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const path = require("path");
+const util_1 = require("../../../../util");
+const parse_1 = require("../../../../parse");
+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.archiving, languageOf: 'gradle' });
+    if (localUri && source && instance.canWrite(localUri, { ownPermissionOnly: true })) {
+        const targetName = projectName ? projectName.replace(/"/g, '\\"') : '';
+        let modified;
+        if (existing) {
+            let match;
+            if (dependencies) {
+                found: {
+                    const pattern = kotlin ? /^\s*include\(((?:\s*"[^"]+"\s*,?\s*)+)\)/gm : /^\s*include\s*((?:(?:"[^"]+"|'[^']+')\s*,?\s*)+)/gm;
+                    while (match = pattern.exec(source)) {
+                        const namespace = /":?([^"]+)"|':?([^']+)'/g;
+                        let app;
+                        while (app = namespace.exec(match[1])) {
+                            if (app[1] === mainParentDir || app[2] === mainParentDir) {
+                                break found;
+                            }
+                        }
+                    }
+                    pattern.lastIndex = 0;
+                    if (match = pattern.exec(source)) {
+                        const index = match.index + match[0].length;
+                        if (kotlin) {
+                            source = source.substring(0, index - 1).trimEnd() + `, "${mainParentDir}")` + source.substring(index);
+                        }
+                        else {
+                            source = parse_1.XmlWriter.replaceMatch(match, source, `, '${mainParentDir}'`, { trimLeading: true });
+                        }
+                        modified = true;
+                    }
+                }
+            }
+            if (targetName) {
+                const value = `rootProject.name = "${targetName}"`;
+                if (match = new RegExp('^\\s*rootProject\\.name\\s*=\\s*' + parse_1.XmlWriter.PATTERN_QUOTEVALUE, 'm').exec(source)) {
+                    source = parse_1.XmlWriter.replaceMatch(match, source, value);
+                }
+                else {
+                    source += (0, util_1.getNewline)(source) + value;
+                }
+                modified = true;
+            }
+        }
+        else {
+            source = (0, util_1.replaceAll)(source, (name) => {
+                switch (name) {
+                    case 'projectName':
+                        return targetName;
+                    case 'name':
+                        return ':' + mainParentDir;
+                    default:
+                        return '';
+                }
+            });
+        }
+        if (modified || !existing) {
+            try {
+                if (instance.writeFile(localUri, source, { encoding: 'utf-8', ownPermissionOnly: true, throwsPermission: true }) && !existing) {
+                    this.add(localUri);
+                }
+            }
+            catch (err) {
+                this.writeFail(["Unable to write file" /* ERR_MESSAGE.WRITE_FILE */, path.basename(localUri)], err, 8192 /* LOG_TYPE.PERMISSION */);
+            }
+        }
+    }
+}
+exports.default = finalize;
+
+if (exports.default) {
+    module.exports = exports.default;
+    module.exports.default = exports.default;
+}