@neurodevs/meta-node 0.19.12 → 0.19.14

package/.vscode/launch.json

@@ -17,6 +17,7 @@
 			"runtimeArgs": [
 				"--inspect-brk",
 				"--trace-warnings",
+				"--experimental-vm-modules",
 				"${workspaceFolder}/node_modules/.bin/jest",
 				"${fileBasenameNoExtension}",
 				"--detectOpenHandles"

package/build/__tests__/impl/NpmAutopackage.test.d.ts

@@ -13,16 +13,29 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
     private static readonly packageDir;
     private static readonly packageJsonPath;
     private static readonly gitignorePath;
-    private static readonly buildDirGitignorePattern;
+    private static readonly originalGitignore;
+    private static readonly updatedGitignore;
+    private static readonly tsconfigPath;
     private static readonly tasksJsonPath;
     private static readonly testDirPath;
     private static readonly abstractTestPath;
+    private static readonly eslintConfigMjsPath;
+    private static readonly eslintConfigJsPath;
+    private static readonly prettierConfigPath;
+    private static readonly customLib;
+    private static readonly customType;
+    private static readonly customInclude;
+    private static readonly customOption;
     private static readonly setupVscodeCmd;
     private static readonly checkGenerateIdVersionCmd;
     private static readonly checkNodeTddVersionCmd;
+    private static readonly checkEslintConfigNdxVersionCmd;
+    private static readonly checkPrettierConfigNdxVersionCmd;
     private static readonly dependencies;
     private static readonly yarnInstallDevDepsCommand;
     private static readonly abstractTestFile;
+    private static readonly eslintConfigFile;
+    private static readonly prettierConfigFile;
     private static readonly defaultOptions;
     protected static beforeEach(): Promise<void>;
     protected static createsInstance(): Promise<void>;
@@ -38,6 +51,8 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
     protected static thenCommitUpdatePackage(): Promise<void>;
     protected static thenAddBuildDirToGitignore(): Promise<void>;
     protected static thenCommitUpdateGitignore(): Promise<void>;
+    protected static thenUpdatesTsconfig(): Promise<void>;
+    protected static thenCommitsUpdateTsconfig(): Promise<void>;
     protected static thenSpruceSetupVscode(): Promise<void>;
     protected static thenCommitVscodeChanges(): Promise<void>;
     protected static thenUpdatesVscodeTasksJson(): Promise<void>;
@@ -47,9 +62,16 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
     protected static thenInstallsTestsDirectory(): Promise<void>;
     protected static thenInstallsAbstractPackageTest(): Promise<void>;
     protected static thenCommitsInstallAbstractPackageTest(): Promise<void>;
+    protected static thenDeletesOldEslintConfigMjs(): Promise<void>;
+    protected static thenInstallsNewEslintConfigJs(): Promise<void>;
+    protected static thenCommitsInstallEslintConfigFile(): Promise<void>;
+    protected static thenInstallsPrettierConfigFile(): Promise<void>;
+    protected static thenCommitsInstallPrettierConfigFile(): Promise<void>;
     protected static lastlyOpensVscodeAtEnd(): Promise<void>;
     protected static installsDevDependenciesIfGenerateIdNotLatest(): Promise<void>;
     protected static installsDevDependenciesIfNodeTddNotLatest(): Promise<void>;
+    protected static installsDevDependenciesIfEslintConfigNdxNotLatest(): Promise<void>;
+    protected static installsDevDependenciesIfPrettierConfigNdxNotLatest(): Promise<void>;
     protected static makeNpmNamespaceOptional(): Promise<void>;
     protected static doesNotCreateRepoInGithubOrgIfDone(): Promise<void>;
     protected static doesNotCloneRepoIfDone(): Promise<void>;
@@ -58,6 +80,7 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
     protected static doesNotCommitCreatePackageIfDone(): Promise<void>;
     protected static doesNotCommitUpdatePackageIfDone(): Promise<void>;
     protected static doesNotCommitUpdateGitignoreIfDone(): Promise<void>;
+    protected static doesNotCommitUpdateTsconfigIfDone(): Promise<void>;
     protected static doesNotCommitSetupVscodeIfDone(): Promise<void>;
     protected static doesNotOverrideOriginalDependencies(): Promise<void>;
     protected static doesNotUpdateTasksJsonIfAlreadyDone(): Promise<void>;
@@ -65,8 +88,12 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
     protected static doesNotThrowIfGenerateIdNotInPackageJson(): Promise<void>;
     protected static doesNotInstallAbstractPackageTestIfTsExists(): Promise<void>;
     protected static doesNotInstallAbstractPackageTestIfTsxExists(): Promise<void>;
+    protected static doesNotRemoveEslintConfigMjsIfNotExists(): Promise<void>;
+    protected static doesNotInstallEslintConfigFileIfExists(): Promise<void>;
+    protected static doesNotInstallPrettierConfigFileIfExists(): Promise<void>;
     private static run;
-    private static createAndRunAutopackage;
+    private static runTwice;
+    private static setShouldInstallDevDeps;
     private static get scopedPackageName();
     private static get createModuleCmd();
     private static orderJsonKeys;
@@ -82,6 +109,8 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
     private static get orgsUrl();
     private static get originalPackageJson();
     private static get updatedPackageJson();
+    private static get originalTsconfig();
+    private static get updatedTsconfig();
     private static originalTasksJson;
     private static get updatedTasksJson();
     private static NpmAutopackage;

package/build/__tests__/impl/NpmAutopackage.test.js

@@ -28,18 +28,29 @@ export default class NpmAutopackageTest extends AbstractPackageTest {
     static packageDir = path.join(this.installDir, this.packageName);
     static packageJsonPath = path.join(this.packageDir, 'package.json');
     static gitignorePath = path.join(this.packageDir, '.gitignore');
-    static buildDirGitignorePattern = '\nbuild/\n';
+    static originalGitignore = this.generateId();
+    static updatedGitignore = `${this.originalGitignore}\nbuild/`;
+    static tsconfigPath = path.join(this.packageDir, 'tsconfig.json');
     static tasksJsonPath = path.join(this.packageDir, '.vscode', 'tasks.json');
     static testDirPath = path.join(this.packageDir, 'src', '__tests__');
     static abstractTestPath = path.join(this.testDirPath, 'AbstractPackageTest.ts');
+    static eslintConfigMjsPath = path.join(this.packageDir, 'eslint.config.mjs');
+    static eslintConfigJsPath = path.join(this.packageDir, 'eslint.config.js');
+    static prettierConfigPath = path.join(this.packageDir, 'prettier.config.js');
+    static customLib = this.generateId();
+    static customType = this.generateId();
+    static customInclude = this.generateId();
+    static customOption = this.generateId();
     static setupVscodeCmd = 'spruce setup.vscode --all true';
     static checkGenerateIdVersionCmd = `yarn info @neurodevs/generate-id version --silent`;
     static checkNodeTddVersionCmd = `yarn info @neurodevs/node-tdd version --silent`;
+    static checkEslintConfigNdxVersionCmd = `yarn info @neurodevs/eslint-config-ndx version --silent`;
+    static checkPrettierConfigNdxVersionCmd = `yarn info @neurodevs/prettier-config-ndx version --silent`;
     static dependencies = {
         [this.generateId()]: this.generateId(),
         [this.generateId()]: this.generateId(),
     };
-    static yarnInstallDevDepsCommand = 'yarn add -D @neurodevs/generate-id@latest @neurodevs/node-tdd@latest';
+    static yarnInstallDevDepsCommand = 'yarn add -D @neurodevs/generate-id @neurodevs/node-tdd @neurodevs/eslint-config-ndx @neurodevs/prettier-config-ndx';
     static abstractTestFile = `import AbstractModuleTest from '@neurodevs/node-tdd'
 
 export default abstract class AbstractPackageTest extends AbstractModuleTest {
@@ -47,6 +58,14 @@ export default abstract class AbstractPackageTest extends AbstractModuleTest {
         await super.beforeEach()
     }
 }
+`;
+    static eslintConfigFile = `import esConfigNdx from './src/eslint.config.js'
+
+export default esConfigNdx
+`;
+    static prettierConfigFile = `import prettierConfigNdx from '@neurodevs/prettier-config-ndx'
+
+export default prettierConfigNdx
 `;
     static defaultOptions = {
         installDir: this.installDir,
@@ -191,7 +210,7 @@ export default abstract class AbstractPackageTest extends AbstractModuleTest {
         await this.run();
         assert.isEqualDeep(callsToWriteFile[1], {
             file: this.gitignorePath,
-            data: this.buildDirGitignorePattern,
+            data: '\nbuild/\n',
             options: { encoding: 'utf-8', flag: 'a' },
         }, 'Did not update .gitignore as expected!');
     }
@@ -202,6 +221,21 @@ export default abstract class AbstractPackageTest extends AbstractModuleTest {
             cwd: this.packageDir,
         }, 'Did not commit .gitignore changes!');
     }
+    static async thenUpdatesTsconfig() {
+        await this.run();
+        assert.isEqualDeep(callsToWriteFile[2], {
+            file: this.tsconfigPath,
+            data: JSON.stringify(this.updatedTsconfig, null, 4) + '\n',
+            options: { encoding: 'utf-8', flag: 'a' },
+        }, 'Did not update tsconfig as expected!');
+    }
+    static async thenCommitsUpdateTsconfig() {
+        await this.run();
+        assert.isEqualDeep(FakeAutocommit.callsToConstructor[3], {
+            commitMessage: `patch: update tsconfig (@neurodevs/meta-node: ${this.metaNodeVersion})`,
+            cwd: this.packageDir,
+        }, 'Did not commit tsconfig changes!');
+    }
     static async thenSpruceSetupVscode() {
         await this.run();
         assert.isEqualDeep(callsToExec[5], {
@@ -211,14 +245,14 @@ export default abstract class AbstractPackageTest extends AbstractModuleTest {
     }
     static async thenCommitVscodeChanges() {
         await this.run();
-        assert.isEqualDeep(FakeAutocommit.callsToConstructor[3], {
+        assert.isEqualDeep(FakeAutocommit.callsToConstructor[4], {
             commitMessage: `patch: setup vscode (@neurodevs/meta-node: ${this.metaNodeVersion})`,
             cwd: this.packageDir,
         }, 'Did not commit vscode changes!');
     }
     static async thenUpdatesVscodeTasksJson() {
         await this.run();
-        assert.isEqualDeep(callsToWriteFile[2], {
+        assert.isEqualDeep(callsToWriteFile[3], {
             file: this.tasksJsonPath,
             data: this.updatedTasksJson,
             options: { encoding: 'utf-8' },
@@ -226,21 +260,23 @@ export default abstract class AbstractPackageTest extends AbstractModuleTest {
     }
     static async thenCommitsUpdateVscodeTasksJson() {
         await this.run();
-        assert.isEqualDeep(FakeAutocommit.callsToConstructor[4], {
+        assert.isEqualDeep(FakeAutocommit.callsToConstructor[5], {
             commitMessage: `patch: update vscode tasks.json (@neurodevs/meta-node: ${this.metaNodeVersion})`,
             cwd: this.packageDir,
         }, 'Did not commit updated vscode tasks.json changes!');
     }
     static async thenInstallsDefaultDevDependencies() {
+        this.setShouldInstallDevDeps();
         await this.run();
-        assert.isEqualDeep(callsToExec[8], {
+        assert.isEqualDeep(callsToExec[10], {
             command: this.yarnInstallDevDepsCommand,
             options: { cwd: this.packageDir },
         }, 'Did not install default devDependencies!');
     }
     static async thenCommitsInstallDefaultDevDependencies() {
+        this.setShouldInstallDevDeps();
         await this.run();
-        assert.isEqualDeep(FakeAutocommit.callsToConstructor[5], {
+        assert.isEqualDeep(FakeAutocommit.callsToConstructor[6], {
             commitMessage: `patch: install default devDependencies (@neurodevs/meta-node: ${this.metaNodeVersion})`,
             cwd: this.packageDir,
         }, 'Did not commit install devDependencies changes!');
@@ -253,29 +289,74 @@ export default abstract class AbstractPackageTest extends AbstractModuleTest {
         }, 'Did not install tests directory!');
     }
     static async thenInstallsAbstractPackageTest() {
+        this.setShouldInstallDevDeps();
         await this.run();
-        assert.isEqualDeep(callsToWriteFile[3], {
+        assert.isEqualDeep(callsToWriteFile[4], {
             file: this.abstractTestPath,
             data: this.abstractTestFile,
             options: { encoding: 'utf-8' },
         }, 'Did not install AbstractPackageTest!');
     }
     static async thenCommitsInstallAbstractPackageTest() {
+        this.setShouldInstallDevDeps();
         await this.run();
-        assert.isEqualDeep(FakeAutocommit.callsToConstructor[6], {
+        assert.isEqualDeep(FakeAutocommit.callsToConstructor[7], {
             commitMessage: `patch: install AbstractPackageTest (@neurodevs/meta-node: ${this.metaNodeVersion})`,
             cwd: this.packageDir,
         }, 'Did not commit install AbstractPackageTest changes!');
     }
+    static async thenDeletesOldEslintConfigMjs() {
+        setPathShouldExist(path.join(this.packageDir, 'eslint.config.mjs'), true);
+        this.setShouldInstallDevDeps();
+        await this.run();
+        assert.isEqualDeep(callsToExec[11], {
+            command: `git rm eslint.config.mjs`,
+            options: { cwd: this.packageDir },
+        }, 'Did not delete old eslint.config.mjs!');
+    }
+    static async thenInstallsNewEslintConfigJs() {
+        this.setShouldInstallDevDeps();
+        await this.run();
+        assert.isEqualDeep(callsToWriteFile[5], {
+            file: this.eslintConfigJsPath,
+            data: this.eslintConfigFile,
+            options: { encoding: 'utf-8' },
+        }, 'Did not install eslint.config.js!');
+    }
+    static async thenCommitsInstallEslintConfigFile() {
+        this.setShouldInstallDevDeps();
+        await this.run();
+        assert.isEqualDeep(FakeAutocommit.callsToConstructor[8], {
+            commitMessage: `patch: install eslint.config.js (@neurodevs/meta-node: ${this.metaNodeVersion})`,
+            cwd: this.packageDir,
+        }, 'Did not commit install eslint.config.js changes!');
+    }
+    static async thenInstallsPrettierConfigFile() {
+        this.setShouldInstallDevDeps();
+        await this.run();
+        assert.isEqualDeep(callsToWriteFile[6], {
+            file: this.prettierConfigPath,
+            data: this.prettierConfigFile,
+            options: { encoding: 'utf-8' },
+        }, 'Did not install prettier.config.js!');
+    }
+    static async thenCommitsInstallPrettierConfigFile() {
+        this.setShouldInstallDevDeps();
+        await this.run();
+        assert.isEqualDeep(FakeAutocommit.callsToConstructor[9], {
+            commitMessage: `patch: install prettier.config.js (@neurodevs/meta-node: ${this.metaNodeVersion})`,
+            cwd: this.packageDir,
+        }, 'Did not commit install prettier.config.js changes!');
+    }
     static async lastlyOpensVscodeAtEnd() {
         await this.run();
-        assert.isEqualDeep(callsToExec[9], { command: 'code .', options: { cwd: this.packageDir } }, 'Did not open vscode at end!');
+        assert.isEqualDeep(callsToExec[11], { command: 'code .', options: { cwd: this.packageDir } }, 'Did not open vscode at end!');
     }
     static async installsDevDependenciesIfGenerateIdNotLatest() {
         setFakeExecResult(this.checkGenerateIdVersionCmd, {
             stdout: '0.0.1',
         });
-        await this.createAndRunAutopackage();
+        await this.runTwice();
         const calls = callsToExec.filter((call) => call?.command === this.yarnInstallDevDepsCommand);
         assert.isEqualDeep(calls[0], {
             command: this.yarnInstallDevDepsCommand,
@@ -283,13 +364,26 @@ export default abstract class AbstractPackageTest extends AbstractModuleTest {
         }, 'Should install default devDependencies if not already installed!');
     }
     static async installsDevDependenciesIfNodeTddNotLatest() {
-        setFakeExecResult(this.checkGenerateIdVersionCmd, {
-            stdout: '1.0.0',
-        });
-        setFakeExecResult(this.checkNodeTddVersionCmd, {
-            stdout: '0.0.1',
-        });
-        await this.createAndRunAutopackage();
+        this.setShouldInstallDevDeps();
+        await this.runTwice();
+        const calls = callsToExec.filter((call) => call?.command === this.yarnInstallDevDepsCommand);
+        assert.isEqualDeep(calls[0], {
+            command: this.yarnInstallDevDepsCommand,
+            options: { cwd: this.packageDir },
+        }, 'Should install default devDependencies if not already installed!');
+    }
+    static async installsDevDependenciesIfEslintConfigNdxNotLatest() {
+        this.setShouldInstallDevDeps();
+        await this.runTwice();
+        const calls = callsToExec.filter((call) => call?.command === this.yarnInstallDevDepsCommand);
+        assert.isEqualDeep(calls[0], {
+            command: this.yarnInstallDevDepsCommand,
+            options: { cwd: this.packageDir },
+        }, 'Should install default devDependencies if not already installed!');
+    }
+    static async installsDevDependenciesIfPrettierConfigNdxNotLatest() {
+        this.setShouldInstallDevDeps();
+        await this.runTwice();
         const calls = callsToExec.filter((call) => call?.command === this.yarnInstallDevDepsCommand);
         assert.isEqualDeep(calls[0], {
             command: this.yarnInstallDevDepsCommand,
@@ -305,87 +399,122 @@ export default abstract class AbstractPackageTest extends AbstractModuleTest {
         assert.doesInclude(callsToWriteFile[0]?.data, `"name": "${this.packageName}"`, 'Did not handle missing npmNamespace!');
     }
     static async doesNotCreateRepoInGithubOrgIfDone() {
-        const fakeResponse = new Response(null, {
-            status: 200,
-            statusText: 'OK',
-        });
-        setFakeFetchResponse(this.reposUrl, fakeResponse);
-        await this.createAndRunAutopackage();
+        await this.runTwice();
         const numCalls = callsToFetch.filter((call) => call.input === this.orgsUrl).length;
-        assert.isEqual(numCalls, 0, 'Should not have created repo!');
+        assert.isEqual(numCalls, 1, 'Should have created repo once!');
     }
     static async doesNotCloneRepoIfDone() {
-        await this.createAndRunAutopackage();
+        await this.runTwice();
         assert.isEqual(callsToExec.filter((call) => call?.command ===
             `git clone https://github.com/${this.gitNamespace}/${this.packageName}.git`).length, 1, 'Did not clone repo once!');
     }
     static async doesNotSpruceCreateModuleIfDone() {
-        await this.createAndRunAutopackage();
+        await this.runTwice();
         assert.isEqual(callsToExec.filter((call) => call?.command === this.createModuleCmd)
             .length, 1, 'Did not call spruce create.module once!');
     }
     static async doesNotRunSetupVscodeIfDone() {
-        await this.createAndRunAutopackage();
+        await this.runTwice();
         assert.isEqual(callsToExec.filter((call) => call?.command === this.setupVscodeCmd)
             .length, 1, 'Did not call spruce setup.vscode once!');
     }
     static async doesNotCommitCreatePackageIfDone() {
-        await this.createAndRunAutopackage();
+        await this.runTwice();
         assert.isEqual(FakeAutocommit.callsToConstructor.filter((call) => call?.commitMessage ===
             `patch: create package (@neurodevs/meta-node: ${this.metaNodeVersion})`).length, 1, 'Did not commit create package changes once!');
     }
     static async doesNotCommitUpdatePackageIfDone() {
-        await this.createAndRunAutopackage();
+        await this.runTwice();
         assert.isEqual(FakeAutocommit.callsToConstructor.filter((call) => call?.commitMessage ===
             `patch: update package.json (@neurodevs/meta-node: ${this.metaNodeVersion})`).length, 1, 'Did not commit update package changes once!');
     }
     static async doesNotCommitUpdateGitignoreIfDone() {
-        await this.createAndRunAutopackage();
+        await this.runTwice();
         assert.isEqual(FakeAutocommit.callsToConstructor.filter((call) => call?.commitMessage ===
             `patch: add build dir to gitignore (@neurodevs/meta-node: ${this.metaNodeVersion})`).length, 1, 'Did not commit gitignore changes once!');
     }
+    static async doesNotCommitUpdateTsconfigIfDone() {
+        await this.runTwice();
+        assert.isEqual(FakeAutocommit.callsToConstructor.filter((call) => call?.commitMessage ===
+            `patch: update tsconfig (@neurodevs/meta-node: ${this.metaNodeVersion})`).length, 1, 'Did not commit tsconfig changes once!');
+    }
     static async doesNotCommitSetupVscodeIfDone() {
-        await this.createAndRunAutopackage();
+        await this.runTwice();
         assert.isEqual(FakeAutocommit.callsToConstructor.filter((call) => call?.commitMessage ===
             `patch: setup vscode (@neurodevs/meta-node: ${this.metaNodeVersion})`).length, 1, 'Did not commit vscode changes once!');
     }
     static async doesNotOverrideOriginalDependencies() {
-        await this.createAndRunAutopackage();
+        await this.runTwice();
         assert.isEqualDeep(JSON.parse(callsToWriteFile[0]?.data).dependencies, this.dependencies, 'Did not update package.json as expected!');
     }
     static async doesNotUpdateTasksJsonIfAlreadyDone() {
-        setFakeReadFileResult(this.tasksJsonPath, this.updatedTasksJson);
-        await this.createAndRunAutopackage();
+        await this.runTwice();
         assert.isEqualDeep(callsToWriteFile.filter((call) => call.file === this.tasksJsonPath)
-            .length, 0, 'Did not update tasks.json once!');
+            .length, 1, 'Did not update tasks.json once!');
     }
     static async doesNotOpenVscodeIfNotCloned() {
         setPathShouldExist(this.packageDir, true);
-        await this.createAndRunAutopackage();
+        await this.run();
         assert.isFalse(callsToExec.some((call) => call?.command === 'code .'), 'Should not open vscode if not cloned!');
     }
     static async doesNotThrowIfGenerateIdNotInPackageJson() {
         setFakeReadFileResult(this.packageJsonPath, this.originalPackageJson.replace('@neurodevs/generate-id', ''));
-        await this.createAndRunAutopackage();
+        await this.runTwice();
     }
     static async doesNotInstallAbstractPackageTestIfTsExists() {
         setPathShouldExist(this.abstractTestPath, true);
-        await this.createAndRunAutopackage();
+        await this.run();
         const calls = callsToWriteFile.filter((call) => call.file === this.abstractTestPath);
         assert.isEqual(calls.length, 0, 'Should not install AbstractPackageTest.ts if already exists!');
     }
     static async doesNotInstallAbstractPackageTestIfTsxExists() {
         setPathShouldExist(`${this.abstractTestPath}x`, true);
-        await this.createAndRunAutopackage();
+        await this.run();
         const calls = callsToWriteFile.filter((call) => call.file === this.abstractTestPath);
         assert.isEqual(calls.length, 0, 'Should not install AbstractPackageTest.tsx if already exists!');
     }
+    static async doesNotRemoveEslintConfigMjsIfNotExists() {
+        setPathShouldExist(this.eslintConfigMjsPath, false);
+        await this.run();
+        const calls = callsToExec.filter((call) => call?.command === `git rm eslint.config.mjs`);
+        assert.isEqual(calls.length, 0, 'Should not remove eslint.config.mjs if it does not exist!');
+    }
+    static async doesNotInstallEslintConfigFileIfExists() {
+        setPathShouldExist(this.eslintConfigJsPath, true);
+        await this.run();
+        const calls = callsToWriteFile.filter((call) => call.file === this.eslintConfigJsPath);
+        assert.isEqual(calls.length, 0, 'Should not install eslint.config.js if already exists!');
+    }
+    static async doesNotInstallPrettierConfigFileIfExists() {
+        setPathShouldExist(this.prettierConfigPath, true);
+        await this.run();
+        const calls = callsToWriteFile.filter((call) => call.file === this.prettierConfigPath);
+        assert.isEqual(calls.length, 0, 'Should not install prettier.config.js if already exists!');
+    }
     static async run() {
         await this.instance.run();
     }
-    static async createAndRunAutopackage() {
-        const instance = this.NpmAutopackage();
-        await instance.run();
+    static async runTwice() {
+        await this.run();
+        setPathShouldExist(this.packageDir, true);
+        setPathShouldExist(this.packageJsonPath, true);
+        setPathShouldExist(this.abstractTestPath, true);
+        setPathShouldExist(this.tasksJsonPath, true);
+        setFakeReadFileResult(this.packageJsonPath, this.updatedPackageJson);
+        setFakeReadFileResult(this.gitignorePath, this.updatedGitignore);
+        setFakeReadFileResult(this.tasksJsonPath, this.updatedTasksJson);
+        setFakeReadFileResult(this.tsconfigPath, JSON.stringify(this.updatedTsconfig));
+        const fakeResponse = new Response(null, {
+            status: 200,
+            statusText: 'OK',
+        });
+        setFakeFetchResponse(this.reposUrl, fakeResponse);
+        await this.run();
+    }
+    static setShouldInstallDevDeps() {
+        setFakeExecResult(this.checkGenerateIdVersionCmd, {
+            stdout: '0.0.1',
+        });
     }
     static get scopedPackageName() {
         return `@${this.npmNamespace}/${this.packageName}`;
@@ -412,6 +541,18 @@ export default abstract class AbstractPackageTest extends AbstractModuleTest {
         NpmAutopackage.exec = fakeExec;
         resetCallsToExec();
         this.setFakeMetaNodeVersion();
+        setFakeExecResult(this.checkGenerateIdVersionCmd, {
+            stdout: '1.0.0',
+        });
+        setFakeExecResult(this.checkNodeTddVersionCmd, {
+            stdout: '1.0.0',
+        });
+        setFakeExecResult(this.checkEslintConfigNdxVersionCmd, {
+            stdout: '1.0.0',
+        });
+        setFakeExecResult(this.checkPrettierConfigNdxVersionCmd, {
+            stdout: '1.0.0',
+        });
     }
     static fakeFetch() {
         NpmAutopackage.fetch = fakeFetch;
@@ -424,6 +565,9 @@ export default abstract class AbstractPackageTest extends AbstractModuleTest {
     static fakePathExists() {
         NpmAutopackage.pathExists = fakePathExists;
         resetCallsToPathExists();
+        setPathShouldExist(this.packageDir, false);
+        setPathShouldExist(this.packageJsonPath, false);
+        setPathShouldExist(this.tasksJsonPath, false);
         setPathShouldExist(this.abstractTestPath, false);
     }
     static fakeReadFile() {
@@ -431,6 +575,8 @@ export default abstract class AbstractPackageTest extends AbstractModuleTest {
         resetCallsToReadFile();
         setFakeReadFileResult(this.packageJsonPath, this.originalPackageJson);
         setFakeReadFileResult(this.tasksJsonPath, JSON.stringify(this.originalTasksJson));
+        setFakeReadFileResult(this.tsconfigPath, JSON.stringify(this.originalTsconfig));
+        setFakeReadFileResult(this.gitignorePath, this.originalGitignore);
     }
     static fakeWriteFile() {
         NpmAutopackage.writeFile = fakeWriteFile;
@@ -461,6 +607,8 @@ export default abstract class AbstractPackageTest extends AbstractModuleTest {
             devDependencies: {
                 '@neurodevs/generate-id': '^1.0.0',
                 '@neurodevs/node-tdd': '^1.0.0',
+                '@neurodevs/eslint-config-ndx': '^1.0.0',
+                '@neurodevs/prettier-config-ndx': '^1.0.0',
             },
         });
     }
@@ -469,6 +617,7 @@ export default abstract class AbstractPackageTest extends AbstractModuleTest {
             ...JSON.parse(this.originalPackageJson),
             name: this.scopedPackageName,
             description: this.description,
+            type: 'module',
             keywords: this.keywords,
             license: this.license,
             author: this.author,
@@ -484,6 +633,44 @@ export default abstract class AbstractPackageTest extends AbstractModuleTest {
             dependencies: this.dependencies,
         });
     }
+    static get originalTsconfig() {
+        return {
+            compilerOptions: {
+                lib: [this.customLib],
+                types: [this.customType],
+            },
+            include: [this.customInclude],
+            customOption: this.customOption,
+        };
+    }
+    static get updatedTsconfig() {
+        return {
+            ...this.originalTsconfig,
+            compilerOptions: {
+                module: 'nodenext',
+                moduleResolution: 'nodenext',
+                target: 'ES2022',
+                lib: [this.customLib, 'ES2022'],
+                types: [this.customType, 'node'],
+                baseUrl: 'src',
+                outDir: 'build',
+                sourceMap: false,
+                strict: true,
+                noImplicitAny: true,
+                noImplicitReturns: true,
+                noUnusedLocals: true,
+                forceConsistentCasingInFileNames: true,
+                declaration: true,
+                skipLibCheck: true,
+                esModuleInterop: true,
+                moduleDetection: 'force',
+                allowJs: true,
+                resolveJsonModule: true,
+                experimentalDecorators: true,
+            },
+            include: [this.customInclude, './src/*.ts', './src/**/*.ts'],
+        };
+    }
     static originalTasksJson = {
         [this.randomId]: this.randomId,
         tasks: [
@@ -569,6 +756,12 @@ __decorate([
 __decorate([
     test()
 ], NpmAutopackageTest, "thenCommitUpdateGitignore", null);
+__decorate([
+    test()
+], NpmAutopackageTest, "thenUpdatesTsconfig", null);
+__decorate([
+    test()
+], NpmAutopackageTest, "thenCommitsUpdateTsconfig", null);
 __decorate([
     test()
 ], NpmAutopackageTest, "thenSpruceSetupVscode", null);
@@ -596,6 +789,21 @@ __decorate([
 __decorate([
     test()
 ], NpmAutopackageTest, "thenCommitsInstallAbstractPackageTest", null);
+__decorate([
+    test()
+], NpmAutopackageTest, "thenDeletesOldEslintConfigMjs", null);
+__decorate([
+    test()
+], NpmAutopackageTest, "thenInstallsNewEslintConfigJs", null);
+__decorate([
+    test()
+], NpmAutopackageTest, "thenCommitsInstallEslintConfigFile", null);
+__decorate([
+    test()
+], NpmAutopackageTest, "thenInstallsPrettierConfigFile", null);
+__decorate([
+    test()
+], NpmAutopackageTest, "thenCommitsInstallPrettierConfigFile", null);
 __decorate([
     test()
 ], NpmAutopackageTest, "lastlyOpensVscodeAtEnd", null);
@@ -605,6 +813,12 @@ __decorate([
 __decorate([
     test()
 ], NpmAutopackageTest, "installsDevDependenciesIfNodeTddNotLatest", null);
+__decorate([
+    test()
+], NpmAutopackageTest, "installsDevDependenciesIfEslintConfigNdxNotLatest", null);
+__decorate([
+    test()
+], NpmAutopackageTest, "installsDevDependenciesIfPrettierConfigNdxNotLatest", null);
 __decorate([
     test()
 ], NpmAutopackageTest, "makeNpmNamespaceOptional", null);
@@ -629,6 +843,9 @@ __decorate([
 __decorate([
     test()
 ], NpmAutopackageTest, "doesNotCommitUpdateGitignoreIfDone", null);
+__decorate([
+    test()
+], NpmAutopackageTest, "doesNotCommitUpdateTsconfigIfDone", null);
 __decorate([
     test()
 ], NpmAutopackageTest, "doesNotCommitSetupVscodeIfDone", null);
@@ -650,4 +867,13 @@ __decorate([
 __decorate([
     test()
 ], NpmAutopackageTest, "doesNotInstallAbstractPackageTestIfTsxExists", null);
+__decorate([
+    test()
+], NpmAutopackageTest, "doesNotRemoveEslintConfigMjsIfNotExists", null);
+__decorate([
+    test()
+], NpmAutopackageTest, "doesNotInstallEslintConfigFileIfExists", null);
+__decorate([
+    test()
+], NpmAutopackageTest, "doesNotInstallPrettierConfigFileIfExists", null);
 //# sourceMappingURL=NpmAutopackage.test.js.map