dcs-git-utils 1.0.0 → 1.0.9

package/src/sorting.ts

@@ -1,128 +1,128 @@
-import path from "node:path"
-import luaparse from "luaparse"
-import promises from "node:fs/promises"
-import * as _ from "lodash"
-import { fengariSortFile } from "./fengari-wrapper";
-
-const jsonExtensions = ["json", "dtc"];
-
-/**
- * Recursively sorts the keys of an object or elements of an array.
- * This function handles arrays, plain objects, and primitives.
- *
- * @param obj The data structure to sort.
- * @returns A new structure with sorted keys/elements.
- */
-function lodashSortKeysDeep(obj: any): any {
-    if (_.isArray(obj)) {
-        // Handle Arrays: Recursively sort each element
-        return obj.map(lodashSortKeysDeep);
-    }
-
-    if (!_.isPlainObject(obj)) {
-        // Handle Primitives and Non-Plain Objects: Return as is
-        return obj;
-    }
-
-    // Handle Plain Objects: Get sorted keys and build the new object
-    return _.keys(obj)
-        .sort() // Sort the keys alphabetically
-        .reduce((sortedObj: _.Dictionary<any>, key: string) => {
-            // Recursively sort the value for the current key
-            sortedObj[key] = lodashSortKeysDeep(obj[key]);
-            return sortedObj;
-        }, {});
-}
-
-
-const checkCharCount = (old: string, sorted: string) => {
-    return old.replace(/\s/g, "").length === sorted.replace(/\s/g, "").length
-}
-
-export const jsonSort = async (filepath: string) => {
-
-    const fileString = await promises.readFile(filepath, { encoding: 'utf-8' });
-
-    const useCRLF = fileString.includes("\r\n");
-    const EOL = useCRLF ? "\r\n" : "\n";
-
-    const obj = JSON.parse(fileString);
-    const sorted = lodashSortKeysDeep(obj);
-    const stringified = JSON.stringify(sorted);
-    if (!checkCharCount(fileString, stringified)) {
-        throw new Error(`mismatching input file char count to sorted`)
-    }
-
-    const resultString = stringified.replace(/\r?\n/g, EOL);
-    await promises.writeFile(filepath, resultString, 'utf-8');
-    console.log(`Sorted JSON: ${filepath}`)
-}
-
-const isLuaSortable = async (filepath: string) => {
-
-    const filename = path.basename(filepath);
-    const extension = path.extname(filename);
-    const lua = await promises.readFile(filepath, { encoding: 'utf-8' });
-
-    if (extension && extension !== "lua") {
-        return false;
-    }
-
-    try {
-        const ast = luaparse.parse(lua);
-
-        if (ast.type !== 'Chunk' || !ast.body) {
-            return false;
-        }
-
-        for (const statement of ast.body) {
-            let isMatch = false;
-
-            // Check for LOCAL assignment: local Config = {...}
-            if (statement.type === 'LocalStatement') {
-                isMatch = statement.variables.some(v => v.name === filename);
-                if (isMatch) return true;
-            }
-
-            // Check for GLOBAL assignment: Config = {...}
-            else if (statement.type === 'AssignmentStatement') {
-                isMatch = statement.variables.some(v => v.type === 'Identifier' && v.name === filename);
-                if (isMatch) return true;
-            }
-        }
-    }
-    catch {
-        console.log(`luaparse failed: ${filename}`);
-    }
-    return false;
-
-}
-
-const sortFile = async (filepath: string) => {
-
-    const extension = path.extname(filepath);
-
-
-    try {
-        if (extension && jsonExtensions.includes(extension)) {
-            await jsonSort(filepath);
-        }
-        else if (await isLuaSortable(filepath)) {
-            await fengariSortFile(filepath);
-        }
-        else {
-            console.log(`skipping: ${filepath}`);
-        }
-    } catch (err) {
-        console.error(err);
-    }
-
-
-}
-
-export const sortFiles = async (filePaths: string[]) => {
-    for (const filepath of filePaths) {
-        await sortFile(filepath);
-    }
-
+import path from "node:path"
+import luaparse from "luaparse"
+import promises from "node:fs/promises"
+import * as _ from "lodash"
+import { fengariSortFile } from "./fengari-wrapper";
+
+const jsonExtensions = ["json", "dtc"];
+
+/**
+ * Recursively sorts the keys of an object or elements of an array.
+ * This function handles arrays, plain objects, and primitives.
+ *
+ * @param obj The data structure to sort.
+ * @returns A new structure with sorted keys/elements.
+ */
+function lodashSortKeysDeep(obj: any): any {
+    if (_.isArray(obj)) {
+        // Handle Arrays: Recursively sort each element
+        return obj.map(lodashSortKeysDeep);
+    }
+
+    if (!_.isPlainObject(obj)) {
+        // Handle Primitives and Non-Plain Objects: Return as is
+        return obj;
+    }
+
+    // Handle Plain Objects: Get sorted keys and build the new object
+    return _.keys(obj)
+        .sort() // Sort the keys alphabetically
+        .reduce((sortedObj: _.Dictionary<any>, key: string) => {
+            // Recursively sort the value for the current key
+            sortedObj[key] = lodashSortKeysDeep(obj[key]);
+            return sortedObj;
+        }, {});
+}
+
+
+const checkCharCount = (old: string, sorted: string) => {
+    return old.replace(/\s/g, "").length === sorted.replace(/\s/g, "").length
+}
+
+export const jsonSort = async (filepath: string) => {
+
+    const fileString = await promises.readFile(filepath, { encoding: 'utf-8' });
+
+    const useCRLF = fileString.includes("\r\n");
+    const EOL = useCRLF ? "\r\n" : "\n";
+
+    const obj = JSON.parse(fileString);
+    const sorted = lodashSortKeysDeep(obj);
+    const stringified = JSON.stringify(sorted);
+    if (!checkCharCount(fileString, stringified)) {
+        throw new Error(`mismatching input file char count to sorted`)
+    }
+
+    const resultString = stringified.replace(/\r?\n/g, EOL);
+    await promises.writeFile(filepath, resultString, 'utf-8');
+    console.log(`Sorted JSON: ${filepath}`)
+}
+
+const isLuaSortable = async (filepath: string) => {
+
+    const filename = path.basename(filepath);
+    const extension = path.extname(filename);
+    const lua = await promises.readFile(filepath, { encoding: 'utf-8' });
+
+    if (extension && extension !== "lua") {
+        return false;
+    }
+
+    try {
+        const ast = luaparse.parse(lua);
+
+        if (ast.type !== 'Chunk' || !ast.body) {
+            return false;
+        }
+
+        for (const statement of ast.body) {
+            let isMatch = false;
+
+            // Check for LOCAL assignment: local Config = {...}
+            if (statement.type === 'LocalStatement') {
+                isMatch = statement.variables.some(v => v.name === filename);
+                if (isMatch) return true;
+            }
+
+            // Check for GLOBAL assignment: Config = {...}
+            else if (statement.type === 'AssignmentStatement') {
+                isMatch = statement.variables.some(v => v.type === 'Identifier' && v.name === filename);
+                if (isMatch) return true;
+            }
+        }
+    }
+    catch {
+        console.log(`luaparse failed: ${filename}`);
+    }
+    return false;
+
+}
+
+const sortFile = async (filepath: string) => {
+
+    const extension = path.extname(filepath);
+
+
+    try {
+        if (extension && jsonExtensions.includes(extension)) {
+            await jsonSort(filepath);
+        }
+        else if (await isLuaSortable(filepath)) {
+            await fengariSortFile(filepath);
+        }
+        else {
+            console.log(`skipping: ${filepath}`);
+        }
+    } catch (err) {
+        console.error(err);
+    }
+
+
+}
+
+export const sortFiles = async (filePaths: string[]) => {
+    for (const filepath of filePaths) {
+        await sortFile(filepath);
+    }
+
 }

package/src/watchers.ts

@@ -1,58 +1,58 @@
-import * as _ from "lodash"
-import * as chokidar from 'chokidar';
-import { sortFiles } from "./sorting";
-import { handleArchive, unpackMiz } from "./compression";
-import path from "node:path";
-import { debounce } from "lodash";
-
-let locked = false;
-
-const unlock = debounce(() => {
-    locked = false;
-}, 3000);
-
-export const startWatchers = (mizPath: string, outDir: string) => {
-
-
-    chokidar.watch(mizPath, { awaitWriteFinish: true, ignoreInitial: true }).on("change", async () => {
-
-        if (locked) {
-            return;
-        }
-
-        console.log("miz changed");
-
-        locked = true;
-        unlock.cancel();
-        const files = await unpackMiz(mizPath, outDir)
-        const filePaths = files.map(f => path.join(outDir, f.path));
-        await sortFiles(filePaths);
-        await handleArchive(outDir, mizPath);
-        unlock();
-    })
-
-    const outChange = async () => {
-
-        if (locked) {
-            unlock();
-            return;
-        }
-
-        console.log("out changed");
-
-        locked = true;
-        unlock.cancel();
-        await handleArchive(outDir, mizPath);
-        unlock();
-    }
-
-    chokidar.watch(outDir, { ignoreInitial: true })
-        .on("add", async () => {
-            await outChange();
-        }).on("addDir", async () => {
-            await outChange();
-        }).on("change", async () => {
-            await outChange();
-        })
-
+import * as _ from "lodash"
+import * as chokidar from 'chokidar';
+import { sortFiles } from "./sorting";
+import { handleArchive, unpackMiz } from "./compression";
+import path from "node:path";
+import { debounce } from "lodash";
+
+let locked = false;
+
+const unlock = debounce(() => {
+    locked = false;
+}, 3000);
+
+export const startWatchers = (mizPath: string, outDir: string) => {
+
+
+    chokidar.watch(mizPath, { awaitWriteFinish: true, ignoreInitial: true }).on("change", async () => {
+
+        if (locked) {
+            return;
+        }
+
+        console.log("miz changed");
+
+        locked = true;
+        unlock.cancel();
+        const files = await unpackMiz(mizPath, outDir)
+        const filePaths = files.map(f => path.join(outDir, f.path));
+        await sortFiles(filePaths);
+        await handleArchive(outDir, mizPath);
+        unlock();
+    })
+
+    const outChange = async () => {
+
+        if (locked) {
+            unlock();
+            return;
+        }
+
+        console.log("out changed");
+
+        locked = true;
+        unlock.cancel();
+        await handleArchive(outDir, mizPath);
+        unlock();
+    }
+
+    chokidar.watch(outDir, { ignoreInitial: true })
+        .on("add", async () => {
+            await outChange();
+        }).on("addDir", async () => {
+            await outChange();
+        }).on("change", async () => {
+            await outChange();
+        })
+
 }

package/tests/sorting.spec.ts

@@ -1,26 +1,26 @@
-import { describe, it, expect, vi, beforeEach, afterAll } from 'vitest';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { saveConfig } from '../src/config'; // Assume you exported this
-import { jsonSort } from '../src/sorting';
-
-describe('Sorting', () => {
-    const filepath = "./test.json";
-
-    beforeEach(() => {
-        vi.clearAllMocks(); // Reset counters before each test
-    });
-    afterAll(async () => {
-        await fs.rm(filepath);
-    })
-    it('should write sort JSON keys', async () => {
-        // 2. Run your function
-
-        const testData = JSON.stringify({ key: "test", asdf: "test2" });
-        await fs.writeFile(filepath, testData, 'utf-8');
-        await jsonSort(filepath);
-        const sorted = await fs.readFile(filepath, { encoding: 'utf-8' });
-        expect(sorted.indexOf("asdf") > sorted.indexOf("key"));
-
-    });
+import { describe, it, expect, vi, beforeEach, afterAll } from 'vitest';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { saveConfig } from '../src/config'; // Assume you exported this
+import { jsonSort } from '../src/sorting';
+
+describe('Sorting', () => {
+    const filepath = "./test.json";
+
+    beforeEach(() => {
+        vi.clearAllMocks(); // Reset counters before each test
+    });
+    afterAll(async () => {
+        await fs.rm(filepath);
+    })
+    it('should write sort JSON keys', async () => {
+        // 2. Run your function
+
+        const testData = JSON.stringify({ key: "test", asdf: "test2" });
+        await fs.writeFile(filepath, testData, 'utf-8');
+        await jsonSort(filepath);
+        const sorted = await fs.readFile(filepath, { encoding: 'utf-8' });
+        expect(sorted.indexOf("asdf") > sorted.indexOf("key"));
+
+    });
 });