Require Node.js 20

Author: sindresorhus

.github/workflows/main.yml

@@ -10,12 +10,11 @@ jobs:
       fail-fast: false
       matrix:
         node-version:
-          - 22
+          - 24
           - 20
-          - 18
     steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
+      - uses: actions/checkout@v5
+      - uses: actions/setup-node@v5
         with:
           node-version: ${{ matrix.node-version }}
       - run: npm install

package.json

@@ -17,10 +17,10 @@
 	},
 	"sideEffects": false,
 	"engines": {
-		"node": ">=18"
+		"node": ">=20"
 	},
 	"scripts": {
-		"test": "xo && ava && tsd"
+		"test": "xo && node test.js && tsd"
 	},
 	"files": [
 		"index.js",
@@ -43,13 +43,11 @@
 	"dependencies": {
 		"detect-indent": "^7.0.1",
 		"is-plain-obj": "^4.1.0",
-		"sort-keys": "^5.0.0",
-		"write-file-atomic": "^5.0.1"
+		"sort-keys": "^6.0.0",
+		"write-file-atomic": "^6.0.0"
 	},
 	"devDependencies": {
-		"ava": "^6.1.3",
-		"tempy": "^2.0.0",
-		"tsd": "^0.31.1",
-		"xo": "^0.59.2"
+		"tsd": "^0.33.0",
+		"xo": "^1.2.2"
 	}
 }

test.js

@@ -1,77 +1,191 @@
-import fs from 'node:fs';
-import test from 'ava';
-import tempy from 'tempy';
+import fs, {promises as fsPromises} from 'node:fs';
+import path from 'node:path';
+import {fileURLToPath} from 'node:url';
+import {test} from 'node:test';
+import assert from 'node:assert/strict';
+import {setTimeout as delay} from 'node:timers/promises';
+import {tmpdir} from 'node:os';
 import {writeJsonFile, writeJsonFileSync} from './index.js';
 
-test('async', async t => {
-	const temporaryFile = tempy.file();
-	await writeJsonFile(temporaryFile, {foo: true}, {indent: 2});
-	t.is(fs.readFileSync(temporaryFile, 'utf8'), '{\n  "foo": true\n}\n');
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+function temporaryFile() {
+	return path.join(tmpdir(), `write-json-file-test-${Date.now()}-${Math.random().toString(36).slice(2)}.json`);
+}
+
+test('async', async () => {
+	const temporaryFilePath = temporaryFile();
+	await writeJsonFile(temporaryFilePath, {foo: true}, {indent: 2});
+	assert.equal(fs.readFileSync(temporaryFilePath, 'utf8'), '{\n  "foo": true\n}\n');
+	fs.unlinkSync(temporaryFilePath);
+});
+
+test('sync', () => {
+	const temporaryFilePath = temporaryFile();
+	writeJsonFileSync(temporaryFilePath, {foo: true}, {detectIndent: true, indent: 2});
+	assert.equal(fs.readFileSync(temporaryFilePath, 'utf8'), '{\n  "foo": true\n}\n');
+	fs.unlinkSync(temporaryFilePath);
 });
 
-test('sync', t => {
-	const temporaryFile = tempy.file();
-	writeJsonFileSync(temporaryFile, {foo: true}, {detectIndent: true, indent: 2});
-	t.is(fs.readFileSync(temporaryFile, 'utf8'), '{\n  "foo": true\n}\n');
+test('detect indent', async () => {
+	const temporaryFilePath = temporaryFile();
+	await writeJsonFile(temporaryFilePath, {foo: true}, {indent: 2});
+	await writeJsonFile(temporaryFilePath, {foo: true, bar: true, foobar: true}, {detectIndent: true});
+	assert.equal(fs.readFileSync(temporaryFilePath, 'utf8'), '{\n  "foo": true,\n  "bar": true,\n  "foobar": true\n}\n');
+	fs.unlinkSync(temporaryFilePath);
 });
 
-test('detect indent', async t => {
-	const temporaryFile = tempy.file();
-	await writeJsonFile(temporaryFile, {foo: true}, {indent: 2});
-	await writeJsonFile(temporaryFile, {foo: true, bar: true, foobar: true}, {detectIndent: true});
-	t.is(fs.readFileSync(temporaryFile, 'utf8'), '{\n  "foo": true,\n  "bar": true,\n  "foobar": true\n}\n');
+test('detect indent synchronously', () => {
+	const temporaryFilePath = temporaryFile();
+	writeJsonFileSync(temporaryFilePath, {foo: true}, {indent: 2});
+	writeJsonFileSync(temporaryFilePath, {foo: true, bar: true, foobar: true}, {detectIndent: true});
+	assert.equal(fs.readFileSync(temporaryFilePath, 'utf8'), '{\n  "foo": true,\n  "bar": true,\n  "foobar": true\n}\n');
+	fs.unlinkSync(temporaryFilePath);
 });
 
-test('detect indent synchronously', t => {
-	const temporaryFile = tempy.file();
-	writeJsonFileSync(temporaryFile, {foo: true}, {indent: 2});
-	writeJsonFileSync(temporaryFile, {foo: true, bar: true, foobar: true}, {detectIndent: true});
-	t.is(fs.readFileSync(temporaryFile, 'utf8'), '{\n  "foo": true,\n  "bar": true,\n  "foobar": true\n}\n');
+test('fall back to default indent if file doesn\'t exist', async () => {
+	const temporaryFilePath = temporaryFile();
+	await writeJsonFile(temporaryFilePath, {foo: true, bar: true, foobar: true}, {detectIndent: true});
+	assert.equal(fs.readFileSync(temporaryFilePath, 'utf8'), '{\n\t"foo": true,\n\t"bar": true,\n\t"foobar": true\n}\n');
+	fs.unlinkSync(temporaryFilePath);
 });
 
-test('fall back to default indent if file doesn\'t exist', async t => {
-	const temporaryFile = tempy.file();
-	await writeJsonFile(temporaryFile, {foo: true, bar: true, foobar: true}, {detectIndent: true});
-	t.is(fs.readFileSync(temporaryFile, 'utf8'), '{\n\t"foo": true,\n\t"bar": true,\n\t"foobar": true\n}\n');
+test('async - {sortKeys: true}', async () => {
+	const temporaryFilePath = temporaryFile();
+	await writeJsonFile(temporaryFilePath, {c: true, b: true, a: true}, {sortKeys: true});
+	assert.equal(fs.readFileSync(temporaryFilePath, 'utf8'), '{\n\t"a": true,\n\t"b": true,\n\t"c": true\n}\n');
+
+	await writeJsonFile(temporaryFilePath, ['c', 'b', 'a'], {sortKeys: true});
+	assert.equal(fs.readFileSync(temporaryFilePath, 'utf8'), '[\n\t"c",\n\t"b",\n\t"a"\n]\n');
+	fs.unlinkSync(temporaryFilePath);
 });
 
-test('async - {sortKeys: true}', async t => {
-	const temporaryFile = tempy.file();
-	await writeJsonFile(temporaryFile, {c: true, b: true, a: true}, {sortKeys: true});
-	t.is(fs.readFileSync(temporaryFile, 'utf8'), '{\n\t"a": true,\n\t"b": true,\n\t"c": true\n}\n');
+test('async - {sortKeys: false}', async () => {
+	const temporaryFilePath = temporaryFile();
+	await writeJsonFile(temporaryFilePath, {c: true, b: true, a: true}, {sortKeys: false});
+	assert.equal(fs.readFileSync(temporaryFilePath, 'utf8'), '{\n\t"c": true,\n\t"b": true,\n\t"a": true\n}\n');
+	fs.unlinkSync(temporaryFilePath);
+});
 
-	await writeJsonFile(temporaryFile, ['c', 'b', 'a'], {sortKeys: true});
-	t.is(fs.readFileSync(temporaryFile, 'utf8'), '[\n\t"c",\n\t"b",\n\t"a"\n]\n');
+test('async - `replacer` option', async () => {
+	const temporaryFilePath = temporaryFile();
+	await writeJsonFile(temporaryFilePath, {foo: true, bar: true}, {replacer: ['foo']});
+	assert.equal(fs.readFileSync(temporaryFilePath, 'utf8'), '{\n\t"foo": true\n}\n');
+	fs.unlinkSync(temporaryFilePath);
 });
 
-test('async - {sortKeys: false}', async t => {
-	const temporaryFile = tempy.file();
-	await writeJsonFile(temporaryFile, {c: true, b: true, a: true}, {sortKeys: false});
-	t.is(fs.readFileSync(temporaryFile, 'utf8'), '{\n\t"c": true,\n\t"b": true,\n\t"a": true\n}\n');
+test('sync - `replacer` option', () => {
+	const temporaryFilePath = temporaryFile();
+	writeJsonFileSync(temporaryFilePath, {foo: true, bar: true}, {replacer: ['foo']});
+	assert.equal(fs.readFileSync(temporaryFilePath, 'utf8'), '{\n\t"foo": true\n}\n');
+	fs.unlinkSync(temporaryFilePath);
 });
 
-test('async - `replacer` option', async t => {
-	const temporaryFile = tempy.file();
-	await writeJsonFile(temporaryFile, {foo: true, bar: true}, {replacer: ['foo']});
-	t.is(fs.readFileSync(temporaryFile, 'utf8'), '{\n\t"foo": true\n}\n');
+test('async - respect trailing newline at the end of the file', async () => {
+	const temporaryFilePath = temporaryFile();
+	fs.writeFileSync(temporaryFilePath, JSON.stringify({foo: true}));
+	await writeJsonFile(temporaryFilePath, {bar: true});
+	assert.equal(fs.readFileSync(temporaryFilePath, 'utf8'), '{\n\t"bar": true\n}');
+	fs.unlinkSync(temporaryFilePath);
 });
 
-test('sync - `replacer` option', t => {
-	const temporaryFile = tempy.file();
-	writeJsonFileSync(temporaryFile, {foo: true, bar: true}, {replacer: ['foo']});
-	t.is(fs.readFileSync(temporaryFile, 'utf8'), '{\n\t"foo": true\n}\n');
+test('sync - respect trailing newline at the end of the file', () => {
+	const temporaryFilePath = temporaryFile();
+	fs.writeFileSync(temporaryFilePath, JSON.stringify({foo: true}));
+	writeJsonFileSync(temporaryFilePath, {bar: true});
+	assert.equal(fs.readFileSync(temporaryFilePath, 'utf8'), '{\n\t"bar": true\n}');
+	fs.unlinkSync(temporaryFilePath);
 });
 
-test('async - respect trailing newline at the end of the file', async t => {
-	const temporaryFile = tempy.file();
-	fs.writeFileSync(temporaryFile, JSON.stringify({foo: true}));
-	await writeJsonFile(temporaryFile, {bar: true});
-	t.is(fs.readFileSync(temporaryFile, 'utf8'), '{\n\t"bar": true\n}');
+test('concurrent writes', async () => {
+	/* eslint-disable no-await-in-loop */
+	const testDir = path.join(__dirname, 'test-temp-concurrent');
+	const targetFile = path.join(testDir, 'concurrent-test.json');
+	const sourceFile = path.join(testDir, 'source.json');
+
+	await fsPromises.rm(testDir, {recursive: true, force: true});
+	await fsPromises.mkdir(testDir, {recursive: true});
+
+	await fsPromises.writeFile(sourceFile, JSON.stringify({test: 'data', value: 1}));
+
+	const errors = [];
+	let successCount = 0;
+
+	async function worker(id) {
+		for (let index = 0; index < 100; index++) {
+			try {
+				const data = JSON.parse(await fsPromises.readFile(sourceFile, 'utf8'));
+				data.worker = id;
+				data.iteration = index;
+				await writeJsonFile(targetFile, data);
+				successCount++;
+			} catch (error) {
+				errors.push({
+					worker: id, iteration: index, error: error.message, code: error.code,
+				});
+			}
+
+			await delay(Math.random() * 10);
+		}
+	}
+
+	const workers = [];
+	for (let index = 0; index < 5; index++) {
+		workers.push(worker(index));
+	}
+
+	await Promise.all(workers);
+
+	assert.equal(successCount, 500, `Expected 500 successful writes, got ${successCount}`);
+	assert.equal(errors.length, 0, `Expected no errors, got ${errors.length}`);
+
+	await fsPromises.rm(testDir, {recursive: true, force: true});
+	/* eslint-enable no-await-in-loop */
 });
 
-test('sync - respect trailing newline at the end of the file', t => {
-	const temporaryFile = tempy.file();
-	fs.writeFileSync(temporaryFile, JSON.stringify({foo: true}));
-	writeJsonFileSync(temporaryFile, {bar: true});
-	t.is(fs.readFileSync(temporaryFile, 'utf8'), '{\n\t"bar": true\n}');
+test('aggressive concurrent writes', async () => {
+	/* eslint-disable no-await-in-loop */
+	const testDir = path.join(__dirname, 'test-temp-aggressive');
+	const sourceFile = path.join(testDir, 'bar.json');
+	const targetFile = path.join(testDir, 'foo.json');
+
+	await fsPromises.rm(testDir, {recursive: true, force: true});
+	await fsPromises.mkdir(testDir, {recursive: true});
+
+	await fsPromises.writeFile(sourceFile, JSON.stringify({test: 'data', value: 1}));
+
+	let errorCount = 0;
+	let successCount = 0;
+	const maxIterations = 100;
+
+	async function run() {
+		await delay(10);
+		const file = await fsPromises.readFile(sourceFile, 'utf8');
+		const data = JSON.parse(file);
+		await writeJsonFile(targetFile, data);
+	}
+
+	async function worker() {
+		for (let index = 0; index < maxIterations; index++) {
+			try {
+				await run();
+				successCount++;
+			} catch {
+				errorCount++;
+			}
+		}
+	}
+
+	const workers = [];
+	for (let index = 0; index < 3; index++) {
+		workers.push(worker());
+	}
+
+	await Promise.all(workers);
+
+	assert.equal(successCount, maxIterations * 3, `Expected ${maxIterations * 3} successful writes, got ${successCount}`);
+	assert.equal(errorCount, 0, `Expected no errors, got ${errorCount}`);
+
+	await fsPromises.rm(testDir, {recursive: true, force: true});
+	/* eslint-enable no-await-in-loop */
 });