@zokugun/artifact 0.6.0 → 0.6.2

package/lib/configs/install/read-install-config.js

@@ -9,6 +9,8 @@ const async_1 = __importDefault(require("@zokugun/fs-extra-plus/async"));
 const is_it_type_1 = require("@zokugun/is-it-type");
 const xtry_1 = require("@zokugun/xtry");
 const yaml_1 = __importDefault(require("yaml"));
+const detect_indent_js_1 = require("../../utils/detect-indent.js");
+const has_final_new_line_js_1 = require("../../utils/has-final-new-line.js");
 const constants_js_1 = require("../utils/constants.js");
 const normalize_file_upsert_js_1 = require("../utils/normalize-file-upsert.js");
 async function readInstallConfig(targetPath) {
@@ -29,12 +31,14 @@ async function readInstallConfig(targetPath) {
             finalNewLine: true,
         });
     }
-    const finalNewLine = content.endsWith('\n');
+    const finalNewLine = (0, has_final_new_line_js_1.hasFinalNewLine)(content);
+    const indent = (0, detect_indent_js_1.detectIndent)(content);
     if (type === 'json') {
         return normalizeConfig(JSON.parse(content), {
             name,
             type: 'json',
             finalNewLine,
+            indent,
         });
     }
     else if (type === 'yaml') {
@@ -42,6 +46,7 @@ async function readInstallConfig(targetPath) {
             name,
             type: 'yaml',
             finalNewLine,
+            indent,
         });
     }
     else {
@@ -50,6 +55,7 @@ async function readInstallConfig(targetPath) {
                 name,
                 type: 'json',
                 finalNewLine,
+                indent,
             });
         }
         catch {
@@ -57,13 +63,13 @@ async function readInstallConfig(targetPath) {
                 name,
                 type: 'yaml',
                 finalNewLine,
+                indent,
             });
         }
     }
 }
 function normalizeConfig(data, configStats) {
     const artifacts = {};
-    let constants = {};
     const install = {};
     let update = {};
     let variables = {};
@@ -71,7 +77,6 @@ function normalizeConfig(data, configStats) {
         return (0, xtry_1.ok)({
             config: {
                 artifacts,
-                constants,
                 install,
                 update,
                 variables,
@@ -121,31 +126,24 @@ function normalizeConfig(data, configStats) {
             }
         }
     }
-    if ((0, is_it_type_1.isRecord)(data.constants, (_key, value) => (0, is_it_type_1.isString)(value))) {
-        constants = data.constants;
-    }
     if (data.update === false) {
         update = false;
     }
     else if ((0, is_it_type_1.isRecord)(data.update)) {
         for (const [key, value] of Object.entries(data.update)) {
-            const normalized = (0, normalize_file_upsert_js_1.normalizeFileUpsert)(value, 'update');
+            const normalized = (0, normalize_file_upsert_js_1.normalizeFileUpsert)(key, value, 'update');
             if (normalized.fails) {
                 return normalized;
             }
-            if (update[key]) {
-                return (0, xtry_1.err)(`Conflict with the "${key}" key on "update"1.`);
-            }
             update[key] = normalized.value;
         }
     }
-    if ((0, is_it_type_1.isRecord)(data.variables, (_key, value) => (0, is_it_type_1.isString)(value))) {
+    if ((0, is_it_type_1.isRecord)(data.variables, (_key, value) => (0, is_it_type_1.isPrimitive)(value))) {
         variables = data.variables;
     }
     return (0, xtry_1.ok)({
         config: {
             artifacts,
-            constants,
             install,
             update,
             variables,

package/lib/configs/install/write-install-config.d.ts

@@ -2,4 +2,4 @@ import { type AsyncDResult } from '@zokugun/xtry';
 import { type InstallConfig, type InstallConfigStats } from '../../types/config.js';
 import { type Options } from '../../types/context.js';
 import { type Format } from '../../types/format.js';
-export declare function writeInstallConfig(config: InstallConfig, { name, finalNewLine, type }: InstallConfigStats, formats: Format[], targetPath: string, options: Options): AsyncDResult;
+export declare function writeInstallConfig(config: InstallConfig, { name, finalNewLine, indent, type }: InstallConfigStats, formats: Format[], targetPath: string, options: Options): AsyncDResult;

package/lib/configs/install/write-install-config.js

@@ -7,23 +7,27 @@ exports.writeInstallConfig = writeInstallConfig;
 const path_1 = __importDefault(require("path"));
 const cli_utils_1 = require("@zokugun/cli-utils");
 const async_1 = __importDefault(require("@zokugun/fs-extra-plus/async"));
+const is_it_type_1 = require("@zokugun/is-it-type");
 const xtry_1 = require("@zokugun/xtry");
-const lodash_es_1 = require("lodash-es");
 const yaml_1 = __importDefault(require("yaml"));
 const apply_formatting_js_1 = require("../../steps/apply-formatting.js");
 const insert_final_new_line_js_1 = require("../../steps/insert-final-new-line.js");
 const constants_js_1 = require("../utils/constants.js");
-async function writeInstallConfig(config, { name, finalNewLine, type }, formats, targetPath, options) {
+async function writeInstallConfig(config, { name, finalNewLine, indent, type }, formats, targetPath, options) {
     const exported = {
         $schema: `https://raw.githubusercontent.com/zokugun/artifact/v${constants_js_1.VERSION_RELEASE}/schemas/v${constants_js_1.MAX_VERSION}/install.json`,
         artifacts: config.artifacts,
     };
-    if (!(0, lodash_es_1.isPlainObject)(config.update) || !(0, lodash_es_1.isEmpty)(config.update)) {
+    if ((0, is_it_type_1.isNonEmptyRecord)(config.update)) {
         exported.update = config.update;
     }
+    if ((0, is_it_type_1.isNonEmptyRecord)(config.variables)) {
+        exported.variables = config.variables;
+    }
     const file = {
         name,
         data: type === 'yaml' ? yaml_1.default.stringify(exported) : JSON.stringify(exported, null, '\t'),
+        indent,
         finalNewLine,
     };
     await (0, insert_final_new_line_js_1.insertFinalNewLine)({ mergedTextFiles: [file] });

package/lib/configs/package/read-package-config.js

@@ -44,17 +44,15 @@ async function readPackageConfig(targetPath) {
     }
 }
 function normalizeConfig(data, source) {
-    let constants = {};
     let xtends;
-    const install = {};
+    const install = [];
     let orphan = false;
-    const uninstall = {};
-    let update = {};
+    const uninstall = [];
+    let update = [];
     let variables = {};
     let variants = {};
     if (!data) {
         return (0, xtry_1.ok)({
-            constants,
             extends: xtends,
             install,
             orphan,
@@ -77,9 +75,6 @@ function normalizeConfig(data, source) {
             return (0, xtry_1.err)(`Don't support newer version (v${version}) in the package's "${source}".`);
         }
     }
-    if ((0, is_it_type_1.isRecord)(data.constants, (_key, value) => (0, is_it_type_1.isString)(value))) {
-        constants = data.constants;
-    }
     if ((0, is_it_type_1.isString)(data.extends)) {
         xtends = data.extends;
     }
@@ -89,91 +84,91 @@ function normalizeConfig(data, source) {
     if (data.orphan === true) {
         orphan = true;
     }
-    if ((0, is_it_type_1.isRecord)(data.variables, (_key, value) => (0, is_it_type_1.isString)(value))) {
+    if ((0, is_it_type_1.isRecord)(data.variables, (_key, value) => (0, is_it_type_1.isPrimitive)(value))) {
         variables = data.variables;
     }
     if ((0, is_it_type_1.isRecord)(data.variants, (_key, value) => (0, is_it_type_1.isString)(value) || (0, is_it_type_1.isNumber)(value))) {
         variants = Object.fromEntries(Object.entries(data.variants).map(([key, value]) => [key, (0, is_it_type_1.isNumber)(value) ? String(value) : value]));
     }
-    if ((0, is_it_type_1.isRecord)(data.always)) {
-        for (const [key, value] of Object.entries(data.always)) {
-            const normalized = (0, normalize_file_always_js_1.normalizeFileAlways)(value);
+    if ((0, is_it_type_1.isRecord)(data.install)) {
+        for (const [key, value] of Object.entries(data.install)) {
+            const normalized = (0, normalize_file_upsert_js_1.normalizeFileUpsert)(key, value, 'install');
             if (normalized.fails) {
                 return normalized;
             }
-            const { ifExists, transforms } = normalized.value;
-            install[key] = {
-                ...normalized.value,
-                ifMissing: 'merge',
-            };
-            uninstall[key] = {
-                ifExists: ifExists === 'force-merge' || ifExists === 'merge' || ifExists === 'overwrite' ? 'skip' : ifExists,
-                transforms,
-            };
-            update[key] = {
-                ...normalized.value,
-                ifMissing: 'merge',
-            };
+            install.push(normalized.value);
         }
     }
-    if ((0, is_it_type_1.isRecord)(data.upsert)) {
-        for (const [key, value] of Object.entries(data.upsert)) {
-            const normalized = (0, normalize_file_upsert_js_1.normalizeFileUpsert)(value, 'upsert');
+    if (data.update === false) {
+        update = false;
+    }
+    else if ((0, is_it_type_1.isRecord)(data.update)) {
+        for (const [key, value] of Object.entries(data.update)) {
+            const normalized = (0, normalize_file_upsert_js_1.normalizeFileUpsert)(key, value, 'update');
             if (normalized.fails) {
                 return normalized;
             }
-            install[key] = normalized.value;
-            update[key] = {
-                ...normalized.value,
-            };
+            update.push(normalized.value);
         }
     }
-    if ((0, is_it_type_1.isRecord)(data.install)) {
-        for (const [key, value] of Object.entries(data.install)) {
-            const normalized = (0, normalize_file_upsert_js_1.normalizeFileUpsert)(value, 'install');
+    if ((0, is_it_type_1.isRecord)(data.uninstall)) {
+        for (const [key, value] of Object.entries(data.uninstall)) {
+            const normalized = (0, normalize_file_uninstall_js_1.normalizeFileUninstall)(key, value);
             if (normalized.fails) {
                 return normalized;
             }
-            if (install[key]) {
-                const result = (0, merge_upsert_property_js_1.mergeUpsertProperty)(key, update[key], normalized.value);
-                if (result.fails) {
-                    return result;
-                }
-            }
-            install[key] = normalized.value;
+            uninstall.push(normalized.value);
         }
     }
-    if ((0, is_it_type_1.isRecord)(data.uninstall)) {
-        for (const [key, value] of Object.entries(data.uninstall)) {
-            const normalized = (0, normalize_file_uninstall_js_1.normalizeFileUninstall)(value);
+    if ((0, is_it_type_1.isRecord)(data.upsert)) {
+        for (const [key, value] of Object.entries(data.upsert)) {
+            const normalized = (0, normalize_file_upsert_js_1.normalizeFileUpsert)(key, value, 'upsert');
             if (normalized.fails) {
                 return normalized;
             }
-            uninstall[key] = normalized.value;
+            const result = (0, merge_upsert_property_js_1.mergeUpsertProperty)(normalized.value, install);
+            if (result.fails) {
+                return result;
+            }
+            if (update) {
+                const result = (0, merge_upsert_property_js_1.mergeUpsertProperty)(normalized.value, update);
+                if (result.fails) {
+                    return result;
+                }
+            }
         }
     }
-    if (data.update === false) {
-        update = false;
-    }
-    else if ((0, is_it_type_1.isRecord)(data.update)) {
-        for (const [key, value] of Object.entries(data.update)) {
-            const normalized = (0, normalize_file_upsert_js_1.normalizeFileUpsert)(value, 'update');
+    if ((0, is_it_type_1.isRecord)(data.always)) {
+        for (const [key, value] of Object.entries(data.always)) {
+            const normalized = (0, normalize_file_always_js_1.normalizeFileAlways)(key, value);
             if (normalized.fails) {
                 return normalized;
             }
-            if (update[key]) {
-                const result = (0, merge_upsert_property_js_1.mergeUpsertProperty)(key, update[key], normalized.value);
+            const { ifExists, pattern, transforms } = normalized.value;
+            const result = (0, merge_upsert_property_js_1.mergeUpsertProperty)({
+                ...normalized.value,
+                ifMissing: 'merge',
+            }, install);
+            if (result.fails) {
+                return result;
+            }
+            if (update) {
+                const result = (0, merge_upsert_property_js_1.mergeUpsertProperty)({
+                    ...normalized.value,
+                    ifMissing: 'merge',
+                }, update);
                 if (result.fails) {
                     return result;
                 }
             }
-            else {
-                update[key] = normalized.value;
-            }
+            uninstall.push({
+                ifExists: ifExists === 'force-merge' || ifExists === 'merge' || ifExists === 'overwrite' ? 'skip' : ifExists,
+                pattern,
+                transforms,
+            });
         }
     }
     return (0, xtry_1.ok)({
-        constants,
         extends: xtends,
         install,
         orphan,

package/lib/configs/utils/merge-upsert-property.d.ts

@@ -1,3 +1,3 @@
 import { type DResult } from '@zokugun/xtry';
-import { type FileUpsert } from '../../types/config.js';
-export declare function mergeUpsertProperty(key: string, oldValue: FileUpsert, newValue: FileUpsert): DResult;
+import { type UpsertFileConfig } from '../../types/config.js';
+export declare function mergeUpsertProperty(file: UpsertFileConfig, configs: UpsertFileConfig[]): DResult;

package/lib/configs/utils/merge-upsert-property.js

@@ -1,20 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeUpsertProperty = mergeUpsertProperty;
+const is_it_type_1 = require("@zokugun/is-it-type");
 const xtry_1 = require("@zokugun/xtry");
 const lodash_es_1 = require("lodash-es");
-function mergeUpsertProperty(key, oldValue, newValue) {
+function mergeUpsertProperty(file, configs) {
+    for (const config of configs) {
+        if (config.pattern === file.pattern) {
+            return merge(config, file);
+        }
+    }
+    configs.push(file);
+    return xtry_1.OK;
+}
+function merge(currentValue, newValue) {
     if (newValue.filter) {
-        if (oldValue.filter) {
+        if (currentValue.filter) {
             return (0, xtry_1.err)('Not Implemented: filter');
         }
         else {
-            oldValue.filter = newValue.filter;
+            currentValue.filter = newValue.filter;
         }
     }
     if (newValue.ifExists && newValue.ifExists !== 'merge') {
-        if (oldValue.ifExists) {
-            if (oldValue.ifExists === 'merge' || oldValue.ifExists === newValue.ifExists) {
+        if (currentValue.ifExists) {
+            if (currentValue.ifExists === 'merge' || currentValue.ifExists === newValue.ifExists) {
                 // pass
             }
             else {
@@ -22,12 +32,12 @@ function mergeUpsertProperty(key, oldValue, newValue) {
             }
         }
         else {
-            oldValue.ifExists = newValue.ifExists;
+            currentValue.ifExists = newValue.ifExists;
         }
     }
     if (newValue.ifMissing && newValue.ifMissing !== 'merge') {
-        if (oldValue.ifMissing) {
-            if (oldValue.ifMissing === 'merge' || oldValue.ifMissing === newValue.ifMissing) {
+        if (currentValue.ifMissing) {
+            if (currentValue.ifMissing === 'merge' || currentValue.ifMissing === newValue.ifMissing) {
                 // pass
             }
             else {
@@ -35,33 +45,33 @@ function mergeUpsertProperty(key, oldValue, newValue) {
             }
         }
         else {
-            oldValue.ifMissing = newValue.ifMissing;
+            currentValue.ifMissing = newValue.ifMissing;
         }
     }
     if (newValue.rename) {
-        if (oldValue.rename) {
+        if (currentValue.rename) {
             return (0, xtry_1.err)('Not Implemented: rename');
         }
         else {
-            oldValue.rename = newValue.rename;
+            currentValue.rename = newValue.rename;
         }
     }
     if (newValue.route) {
-        if (oldValue.route) {
+        if (currentValue.route) {
             return (0, xtry_1.err)('Not Implemented: route');
         }
         else {
-            oldValue.route = newValue.route;
+            currentValue.route = newValue.route;
         }
     }
-    if (newValue.transforms && newValue.transforms.length > 0) {
-        if (oldValue.transforms) {
-            if (!(0, lodash_es_1.isEqual)(oldValue.transforms, newValue.transforms)) {
-                return (0, xtry_1.err)(`There is a conflict on the "transforms" property for the "${key}" file`);
+    if ((0, is_it_type_1.isNonEmptyArray)(newValue.transforms)) {
+        if ((0, is_it_type_1.isNonEmptyArray)(currentValue.transforms)) {
+            if (!(0, lodash_es_1.isEqual)(currentValue.transforms, newValue.transforms)) {
+                return (0, xtry_1.err)(`There is a conflict on the "transforms" property for the "${newValue.pattern}" file`);
             }
         }
         else {
-            oldValue.transforms = newValue.transforms;
+            currentValue.transforms = newValue.transforms;
         }
     }
     return xtry_1.OK;

package/lib/configs/utils/normalize-file-always.d.ts

@@ -1,3 +1,3 @@
 import { type DResult } from '@zokugun/xtry';
-import { type FileAlways } from '../../types/config.js';
-export declare function normalizeFileAlways(data: unknown): DResult<FileAlways>;
+import { type AlwaysFileConfig } from '../../types/config.js';
+export declare function normalizeFileAlways(pattern: string, data: unknown): DResult<AlwaysFileConfig>;

package/lib/configs/utils/normalize-file-always.js

@@ -4,7 +4,7 @@ exports.normalizeFileAlways = normalizeFileAlways;
 const is_it_type_1 = require("@zokugun/is-it-type");
 const xtry_1 = require("@zokugun/xtry");
 const is_transform_js_1 = require("./is-transform.js");
-function normalizeFileAlways(data) {
+function normalizeFileAlways(pattern, data) {
     if (!(0, is_it_type_1.isRecord)(data)) {
         return (0, xtry_1.err)('"always" must be an object.');
     }
@@ -23,6 +23,7 @@ function normalizeFileAlways(data) {
     }
     return (0, xtry_1.ok)({
         ifExists,
+        pattern,
         transforms,
     });
 } // }}}

package/lib/configs/utils/normalize-file-uninstall.d.ts

@@ -1,3 +1,3 @@
 import { type DResult } from '@zokugun/xtry';
-import { type FileUninstall } from '../../types/config.js';
-export declare function normalizeFileUninstall(data: unknown): DResult<FileUninstall>;
+import { type UninstallFileConfig } from '../../types/config.js';
+export declare function normalizeFileUninstall(pattern: string, data: unknown): DResult<UninstallFileConfig>;

package/lib/configs/utils/normalize-file-uninstall.js

@@ -4,7 +4,7 @@ exports.normalizeFileUninstall = normalizeFileUninstall;
 const is_it_type_1 = require("@zokugun/is-it-type");
 const xtry_1 = require("@zokugun/xtry");
 const is_transform_js_1 = require("./is-transform.js");
-function normalizeFileUninstall(data) {
+function normalizeFileUninstall(pattern, data) {
     if (!(0, is_it_type_1.isRecord)(data)) {
         return (0, xtry_1.err)('"uninstall" must be an object.');
     }
@@ -26,6 +26,7 @@ function normalizeFileUninstall(data) {
     }
     return (0, xtry_1.ok)({
         ifExists,
+        pattern,
         transforms,
     });
 } // }}}

package/lib/configs/utils/normalize-file-upsert.d.ts

@@ -1,3 +1,3 @@
 import { type DResult } from '@zokugun/xtry';
-import { type FileUpsert } from '../../types/config.js';
-export declare function normalizeFileUpsert(data: unknown, name: 'install' | 'update' | 'upsert'): DResult<FileUpsert>;
+import { type UpsertFileConfig } from '../../types/config.js';
+export declare function normalizeFileUpsert(pattern: string, data: unknown, name: 'install' | 'update' | 'upsert'): DResult<UpsertFileConfig>;

package/lib/configs/utils/normalize-file-upsert.js

@@ -4,7 +4,7 @@ exports.normalizeFileUpsert = normalizeFileUpsert;
 const is_it_type_1 = require("@zokugun/is-it-type");
 const xtry_1 = require("@zokugun/xtry");
 const is_transform_js_1 = require("./is-transform.js");
-function normalizeFileUpsert(data, name) {
+function normalizeFileUpsert(pattern, data, name) {
     if (!(0, is_it_type_1.isRecord)(data)) {
         return (0, xtry_1.err)(`"${name}" must be an object.`);
     }
@@ -47,6 +47,7 @@ function normalizeFileUpsert(data, name) {
         filter,
         ifExists,
         ifMissing,
+        pattern,
         rename,
         route,
         transforms,

package/lib/journeys/commitlint/index.js

@@ -4,14 +4,14 @@ const index_js_1 = require("../../compositors/index.js");
 const index_js_2 = require("../../routes/index.js");
 const build_journey_plan_js_1 = require("../../utils/build-journey-plan.js");
 const build_travel_plan_js_1 = require("../../utils/build-travel-plan.js");
-const mainRoute = (0, index_js_1.compose)({
+const mainRoute = (0, index_js_1.mapSort)((0, index_js_1.compose)({
     extends: index_js_2.listConcat,
     parserPreset: index_js_2.primitive,
-    rules: (0, index_js_1.compose)({
+    rules: (0, index_js_1.mapSort)((0, index_js_1.compose)({
         $$default: index_js_2.overwrite,
-    }),
+    })),
     $$default: index_js_2.primitive,
-});
+}));
 const jsonRoute = (0, index_js_1.json)(mainRoute);
 const yamlRoute = (0, index_js_1.yaml)(mainRoute);
 const rcRoute = (0, index_js_1.rc)(mainRoute);

package/lib/journeys/fixpack/index.js

@@ -1,14 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const lodash_es_1 = require("lodash-es");
+const is_it_type_1 = require("@zokugun/is-it-type");
 const index_js_1 = require("../../compositors/index.js");
 const index_js_2 = require("../../routes/index.js");
 const build_journey_plan_js_1 = require("../../utils/build-journey-plan.js");
 const build_travel_plan_js_1 = require("../../utils/build-travel-plan.js");
-const mainRoute = (0, index_js_1.compose)({
+const mainRoute = (0, index_js_1.mapSort)((0, index_js_1.compose)({
     sortToTop: index_js_2.listSortConcat,
-    $$default: (0, index_js_1.fork)([Array.isArray, index_js_2.listConcat], [lodash_es_1.isPlainObject, index_js_2.mapConcat], index_js_2.primitive),
-});
+    $$default: (0, index_js_1.fork)([is_it_type_1.isArray, index_js_2.listConcat], [is_it_type_1.isRecord, index_js_2.mapConcat], index_js_2.primitive),
+}));
 const jsonRoute = (0, index_js_1.json)(mainRoute);
 const yamlRoute = (0, index_js_1.yaml)(mainRoute);
 const rcRoute = (0, index_js_1.rc)(mainRoute);

package/lib/steps/apply-formatting.d.ts

@@ -1,6 +1,6 @@
 import { type AsyncDResult } from '@zokugun/xtry';
+import { type TextFile } from '../types/context.js';
 import { type Format } from '../types/format.js';
-import { type TextFile } from '../types/text-file.js';
 export declare function applyFormatting({ formats, mergedTextFiles, transformedFiles }: {
     formats: Format[];
     mergedTextFiles: TextFile[];

package/lib/steps/apply-formatting.js

@@ -1,12 +1,9 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyFormatting = applyFormatting;
 const xtry_1 = require("@zokugun/xtry");
-const detect_indent_1 = __importDefault(require("detect-indent"));
 const format_js_1 = require("../types/format.js");
+const detect_indent_js_1 = require("../utils/detect-indent.js");
 const get_format_js_1 = require("../utils/get-format.js");
 function applyFormat(file, format) {
     if (format.indentStyle === format_js_1.IndentStyle.SPACE) {
@@ -23,29 +20,39 @@ function applyFormat(file, format) {
     }
 } // }}}
 function indentWithSpace(data, size) {
-    const { type, indent } = (0, detect_indent_1.default)(data);
-    if (type === 'space') {
-        if (indent.length === size) {
+    const indent = (0, detect_indent_js_1.detectIndent)(data);
+    if (!indent) {
+        return data;
+    }
+    else if (indent.style === format_js_1.IndentStyle.SPACE) {
+        if (indent.size === size) {
             return data;
         }
         else {
-            data = data.replaceAll(new RegExp(indent, 'gm'), '\t');
+            const oldIndent = ' '.repeat(indent.size);
             const newIndent = ' '.repeat(size);
-            return data.replaceAll(/\t/gm, newIndent);
+            const space2tab = new RegExp(`^(?:${oldIndent})+`, 'gm');
+            data = data.replaceAll(space2tab, (spaces) => '\t'.repeat(spaces.length / indent.size));
+            return data.replaceAll(/^\t+/gm, (tabs) => newIndent.repeat(tabs.length));
         }
     }
-    else if (type === 'tab') {
+    else if (indent.style === format_js_1.IndentStyle.TAB) {
         const newIndent = ' '.repeat(size);
-        return data.replaceAll(new RegExp(indent, 'gm'), newIndent);
+        return data.replaceAll(/^\t+/gm, (tabs) => newIndent.repeat(tabs.length));
     }
     else {
         return data;
     }
 } // }}}
 function indentWithTab(data) {
-    const { type, indent, amount } = (0, detect_indent_1.default)(data);
-    if (type === 'space' && amount > 1) {
-        return data.replaceAll(new RegExp(indent, 'gm'), '\t');
+    const indent = (0, detect_indent_js_1.detectIndent)(data);
+    if (!indent) {
+        return data;
+    }
+    else if (indent.style === format_js_1.IndentStyle.SPACE) {
+        const oldIndent = ' '.repeat(indent.size);
+        const space2tab = new RegExp(`^(?:${oldIndent})+`, 'gm');
+        return data.replaceAll(space2tab, (spaces) => '\t'.repeat(spaces.length / indent.size));
     }
     else {
         return data;
@@ -57,6 +64,13 @@ async function applyFormatting({ formats, mergedTextFiles, transformedFiles }) {
         if (format) {
             applyFormat(file, format);
         }
+        else if (file.indent) {
+            applyFormat(file, {
+                indentStyle: file.indent.style,
+                indentSize: file.indent.size,
+                insertFinalNewline: file.finalNewLine,
+            });
+        }
     }
     if (transformedFiles) {
         for (const file of transformedFiles) {
@@ -64,6 +78,13 @@ async function applyFormatting({ formats, mergedTextFiles, transformedFiles }) {
             if (format) {
                 applyFormat(file, format);
             }
+            else if (file.indent) {
+                applyFormat(file, {
+                    indentStyle: file.indent.style,
+                    indentSize: file.indent.size,
+                    insertFinalNewline: file.finalNewLine,
+                });
+            }
         }
     }
     return xtry_1.OK;