@zenfs/devel 0.1.0 → 1.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/bin/make-index.js +37 -74
- package/dist/bin/node-compat.d.ts +2 -0
- package/dist/bin/node-compat.js +340 -0
- package/dist/bin/zci.js +33 -44
- package/dist/bin/zenfs-test.js +45 -78
- package/dist/index.d.ts +1 -0
- package/dist/index.js +1 -0
- package/dist/make_index.d.ts +20 -0
- package/dist/make_index.js +49 -0
- package/dist/node_compat/analysis.d.ts +53 -0
- package/dist/node_compat/analysis.js +60 -0
- package/dist/node_compat/changelog.d.ts +25 -0
- package/dist/node_compat/changelog.js +60 -0
- package/dist/node_compat/commits.d.ts +26 -0
- package/dist/node_compat/commits.js +66 -0
- package/dist/node_compat/config.d.ts +6 -0
- package/dist/node_compat/config.js +18 -0
- package/dist/node_compat/docs.d.ts +58 -0
- package/dist/node_compat/docs.js +213 -0
- package/dist/node_compat/git.d.ts +22 -0
- package/dist/node_compat/git.js +74 -0
- package/dist/node_compat/index.d.ts +10 -0
- package/dist/node_compat/index.js +11 -0
- package/dist/node_compat/node.d.ts +42 -0
- package/dist/node_compat/node.js +84 -0
- package/dist/node_compat/output.d.ts +29 -0
- package/dist/node_compat/output.js +95 -0
- package/dist/node_compat/pr.d.ts +59 -0
- package/dist/node_compat/pr.js +125 -0
- package/dist/node_compat/state.d.ts +18 -0
- package/dist/node_compat/state.js +12 -0
- package/dist/node_compat/versions.d.ts +5 -0
- package/dist/node_compat/versions.js +13 -0
- package/dist/node_compat/zenfs.d.ts +3 -0
- package/dist/node_compat/zenfs.js +108 -0
- package/dist/tests/fs/callbacks.test.d.ts +1 -0
- package/dist/tests/fs/callbacks.test.js +41 -0
- package/dist/tests/fs/cp.test.d.ts +1 -0
- package/dist/tests/fs/cp.test.js +186 -0
- package/dist/tests/fs/dir.test.js +40 -0
- package/dist/tests/fs/directory.test.js +42 -0
- package/dist/tests/fs/links.test.js +36 -0
- package/dist/tests/fs/open.test.js +15 -0
- package/dist/tests/fs/read.test.js +139 -2
- package/dist/tests/fs/readFile.test.js +159 -0
- package/dist/tests/fs/stat.test.js +67 -0
- package/dist/tests/fs/streams.test.js +178 -0
- package/dist/tests/fs/tempdir.test.js +8 -0
- package/dist/tests/fs/truncate.test.js +89 -0
- package/dist/tests/fs/watch.test.js +131 -6
- package/dist/tests/fs/write.test.js +182 -0
- package/package.json +8 -3
|
@@ -1,3 +1,55 @@
|
|
|
1
|
+
var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
|
|
2
|
+
if (value !== null && value !== void 0) {
|
|
3
|
+
if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
|
|
4
|
+
var dispose, inner;
|
|
5
|
+
if (async) {
|
|
6
|
+
if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
|
|
7
|
+
dispose = value[Symbol.asyncDispose];
|
|
8
|
+
}
|
|
9
|
+
if (dispose === void 0) {
|
|
10
|
+
if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
|
|
11
|
+
dispose = value[Symbol.dispose];
|
|
12
|
+
if (async) inner = dispose;
|
|
13
|
+
}
|
|
14
|
+
if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
|
|
15
|
+
if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
|
|
16
|
+
env.stack.push({ value: value, dispose: dispose, async: async });
|
|
17
|
+
}
|
|
18
|
+
else if (async) {
|
|
19
|
+
env.stack.push({ async: true });
|
|
20
|
+
}
|
|
21
|
+
return value;
|
|
22
|
+
};
|
|
23
|
+
var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
|
|
24
|
+
return function (env) {
|
|
25
|
+
function fail(e) {
|
|
26
|
+
env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
|
|
27
|
+
env.hasError = true;
|
|
28
|
+
}
|
|
29
|
+
var r, s = 0;
|
|
30
|
+
function next() {
|
|
31
|
+
while (r = env.stack.pop()) {
|
|
32
|
+
try {
|
|
33
|
+
if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
|
|
34
|
+
if (r.dispose) {
|
|
35
|
+
var result = r.dispose.call(r.value);
|
|
36
|
+
if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
|
|
37
|
+
}
|
|
38
|
+
else s |= 1;
|
|
39
|
+
}
|
|
40
|
+
catch (e) {
|
|
41
|
+
fail(e);
|
|
42
|
+
}
|
|
43
|
+
}
|
|
44
|
+
if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
|
|
45
|
+
if (env.hasError) throw env.error;
|
|
46
|
+
}
|
|
47
|
+
return next();
|
|
48
|
+
};
|
|
49
|
+
})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
|
|
50
|
+
var e = new Error(message);
|
|
51
|
+
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
|
|
52
|
+
});
|
|
1
53
|
// SPDX-License-Identifier: LGPL-3.0-or-later
|
|
2
54
|
import assert from 'node:assert/strict';
|
|
3
55
|
import { suite, test } from 'node:test';
|
|
@@ -14,6 +66,13 @@ suite('Truncating', config('truncate'), () => {
|
|
|
14
66
|
fs.writeFileSync(path, data);
|
|
15
67
|
assert.equal(fs.statSync(path).size, size);
|
|
16
68
|
});
|
|
69
|
+
test('Path functions reject file descriptors', config('sync'), async () => {
|
|
70
|
+
const fd = fs.openSync(path, 'r+');
|
|
71
|
+
const error = { name: 'TypeError', code: 'ERR_INVALID_ARG_TYPE' };
|
|
72
|
+
assert.throws(() => fs.truncateSync(fd, 1), error);
|
|
73
|
+
await assert.rejects(fs.promises.truncate(fd, 1), error);
|
|
74
|
+
fs.closeSync(fd);
|
|
75
|
+
});
|
|
17
76
|
test('FD functions', config('sync'), () => {
|
|
18
77
|
const fd = fs.openSync(path, 'r+');
|
|
19
78
|
fs.ftruncateSync(fd, 1024);
|
|
@@ -59,4 +118,34 @@ suite('Truncating', config('truncate'), () => {
|
|
|
59
118
|
await fs.promises.truncate(path, 10);
|
|
60
119
|
assert.equal(await fs.promises.readFile(path, 'utf8'), 'SECR\0\0\0\0\0\0');
|
|
61
120
|
});
|
|
121
|
+
test('Negative lengths truncate to 0', async () => {
|
|
122
|
+
const env_1 = { stack: [], error: void 0, hasError: false };
|
|
123
|
+
try {
|
|
124
|
+
const path = 'truncate-negative.txt';
|
|
125
|
+
fs.writeFileSync(path, 'abc');
|
|
126
|
+
fs.truncateSync(path, -1);
|
|
127
|
+
assert.equal(fs.statSync(path).size, 0);
|
|
128
|
+
fs.writeFileSync(path, 'abc');
|
|
129
|
+
const fd = fs.openSync(path, 'r+');
|
|
130
|
+
fs.ftruncateSync(fd, -1);
|
|
131
|
+
assert.equal(fs.fstatSync(fd).size, 0);
|
|
132
|
+
fs.closeSync(fd);
|
|
133
|
+
fs.writeFileSync(path, 'abc');
|
|
134
|
+
await fs.promises.truncate(path, -1);
|
|
135
|
+
assert.equal(fs.statSync(path).size, 0);
|
|
136
|
+
fs.writeFileSync(path, 'abc');
|
|
137
|
+
const handle = __addDisposableResource(env_1, await fs.promises.open(path, 'r+'), true);
|
|
138
|
+
await handle.truncate(-1);
|
|
139
|
+
assert.equal((await handle.stat()).size, 0);
|
|
140
|
+
}
|
|
141
|
+
catch (e_1) {
|
|
142
|
+
env_1.error = e_1;
|
|
143
|
+
env_1.hasError = true;
|
|
144
|
+
}
|
|
145
|
+
finally {
|
|
146
|
+
const result_1 = __disposeResources(env_1);
|
|
147
|
+
if (result_1)
|
|
148
|
+
await result_1;
|
|
149
|
+
}
|
|
150
|
+
});
|
|
62
151
|
});
|
|
@@ -154,6 +154,20 @@ suite('Watch', config('watch'), () => {
|
|
|
154
154
|
fs.unwatchFile(testFile, listener);
|
|
155
155
|
}
|
|
156
156
|
});
|
|
157
|
+
test('watchFile() returns a shared StatWatcher', () => {
|
|
158
|
+
const first = () => { };
|
|
159
|
+
const watcher = fs.watchFile(testFile, { interval: 10 }, first);
|
|
160
|
+
assert.equal(fs.watchFile(testFile, () => { }), watcher);
|
|
161
|
+
assert.equal(watcher.ref(), watcher);
|
|
162
|
+
assert.equal(watcher.unref(), watcher);
|
|
163
|
+
assert.equal(watcher.listenerCount('change'), 2);
|
|
164
|
+
fs.unwatchFile(testFile, first);
|
|
165
|
+
assert.equal(watcher.listenerCount('change'), 1);
|
|
166
|
+
fs.unwatchFile(testFile);
|
|
167
|
+
assert.equal(watcher.listenerCount('change'), 0);
|
|
168
|
+
assert.notEqual(fs.watchFile(testFile, () => { }), watcher);
|
|
169
|
+
fs.unwatchFile(testFile);
|
|
170
|
+
});
|
|
157
171
|
test('unwatchFile() works', async () => {
|
|
158
172
|
let changeDetected = false;
|
|
159
173
|
const listener = () => {
|
|
@@ -166,6 +180,15 @@ suite('Watch', config('watch'), () => {
|
|
|
166
180
|
// Wait to see if any change is detected
|
|
167
181
|
assert(!changeDetected);
|
|
168
182
|
});
|
|
183
|
+
test('unwatchFile() emits stop asynchronously', async () => {
|
|
184
|
+
const watcher = fs.watchFile(testFile, () => { });
|
|
185
|
+
let isSync = true;
|
|
186
|
+
const { promise, resolve } = Promise.withResolvers();
|
|
187
|
+
watcher.on('stop', () => resolve(isSync));
|
|
188
|
+
fs.unwatchFile(testFile);
|
|
189
|
+
isSync = false;
|
|
190
|
+
assert.equal(await promise, false);
|
|
191
|
+
});
|
|
169
192
|
test('Directories can be watched', async () => {
|
|
170
193
|
const env_4 = { stack: [], error: void 0, hasError: false };
|
|
171
194
|
try {
|
|
@@ -294,13 +317,93 @@ suite('Watch', config('watch'), () => {
|
|
|
294
317
|
await watcher.return?.();
|
|
295
318
|
}
|
|
296
319
|
});
|
|
297
|
-
test('
|
|
320
|
+
test('Non-recursive watchers ignore nested files', async () => {
|
|
298
321
|
const env_7 = { stack: [], error: void 0, hasError: false };
|
|
322
|
+
try {
|
|
323
|
+
const subDir = `${testDir}/non-recursive`;
|
|
324
|
+
await fs.promises.mkdir(subDir);
|
|
325
|
+
await fs.promises.writeFile(`${subDir}/nested.txt`, '');
|
|
326
|
+
const events = [];
|
|
327
|
+
const { promise, resolve } = Promise.withResolvers();
|
|
328
|
+
const watcher = __addDisposableResource(env_7, fs.watch(testDir, (eventType, filename) => {
|
|
329
|
+
events.push(filename);
|
|
330
|
+
if (filename == 'direct.txt')
|
|
331
|
+
resolve();
|
|
332
|
+
}), false);
|
|
333
|
+
await fs.promises.writeFile(`${subDir}/nested.txt`, 'x');
|
|
334
|
+
await fs.promises.writeFile(`${testDir}/direct.txt`, 'x');
|
|
335
|
+
await withTimeout(promise);
|
|
336
|
+
assert(!events.some(filename => filename.includes('nested.txt')));
|
|
337
|
+
}
|
|
338
|
+
catch (e_7) {
|
|
339
|
+
env_7.error = e_7;
|
|
340
|
+
env_7.hasError = true;
|
|
341
|
+
}
|
|
342
|
+
finally {
|
|
343
|
+
__disposeResources(env_7);
|
|
344
|
+
}
|
|
345
|
+
});
|
|
346
|
+
test('Ignored files do not emit events', async () => {
|
|
347
|
+
const env_8 = { stack: [], error: void 0, hasError: false };
|
|
348
|
+
try {
|
|
349
|
+
const ignoreDir = `${testDir}/ignore`;
|
|
350
|
+
await fs.promises.mkdir(ignoreDir);
|
|
351
|
+
const events = [];
|
|
352
|
+
const { promise, resolve } = Promise.withResolvers();
|
|
353
|
+
const watcher = __addDisposableResource(env_8, fs.watch(ignoreDir, { ignore: ['*.log', /skip/, filename => filename == 'function.txt'] }, (eventType, filename) => {
|
|
354
|
+
events.push(filename);
|
|
355
|
+
if (filename == 'kept.txt')
|
|
356
|
+
resolve();
|
|
357
|
+
}), false);
|
|
358
|
+
for (const name of ['a.log', 'skip.txt', 'function.txt', 'kept.txt'])
|
|
359
|
+
await fs.promises.writeFile(`${ignoreDir}/${name}`, 'x');
|
|
360
|
+
await withTimeout(promise);
|
|
361
|
+
assert(events.every(filename => filename == 'kept.txt'));
|
|
362
|
+
}
|
|
363
|
+
catch (e_8) {
|
|
364
|
+
env_8.error = e_8;
|
|
365
|
+
env_8.hasError = true;
|
|
366
|
+
}
|
|
367
|
+
finally {
|
|
368
|
+
__disposeResources(env_8);
|
|
369
|
+
}
|
|
370
|
+
});
|
|
371
|
+
test('Invalid ignore patterns are rejected', () => {
|
|
372
|
+
assert.throws(() => fs.watch(testDir, { ignore: '' }), { code: 'ERR_INVALID_ARG_VALUE' });
|
|
373
|
+
assert.throws(() => fs.watch(testDir, { ignore: 5 }), { code: 'ERR_INVALID_ARG_TYPE' });
|
|
374
|
+
assert.throws(() => fs.watch(testDir, { ignore: ['*.log', 5] }), { code: 'ERR_INVALID_ARG_TYPE' });
|
|
375
|
+
});
|
|
376
|
+
test('Bursts of events are queued by promises.watch', async () => {
|
|
377
|
+
const burstDir = `${testDir}/burst`;
|
|
378
|
+
await fs.promises.mkdir(burstDir);
|
|
379
|
+
const watcher = fs.promises.watch(burstDir);
|
|
380
|
+
const first = watcher.next();
|
|
381
|
+
await new Promise(resolve => setTimeout(resolve, 20));
|
|
382
|
+
for (let i = 0; i < 3; i++)
|
|
383
|
+
await fs.promises.writeFile(`${burstDir}/file${i}`, 'x');
|
|
384
|
+
await withTimeout(first);
|
|
385
|
+
const names = new Set();
|
|
386
|
+
for (let i = 0; i < 2; i++)
|
|
387
|
+
names.add((await withTimeout(watcher.next())).value.filename);
|
|
388
|
+
await watcher.return?.();
|
|
389
|
+
assert(names.size >= 1);
|
|
390
|
+
});
|
|
391
|
+
test('Invalid queue options are rejected by promises.watch', async () => {
|
|
392
|
+
const start = (options) => async () => {
|
|
393
|
+
const watcher = fs.promises.watch(testDir, options);
|
|
394
|
+
await watcher.next();
|
|
395
|
+
};
|
|
396
|
+
await assert.rejects(start({ overflow: 'throw' }), { code: 'ERR_INVALID_ARG_VALUE' });
|
|
397
|
+
await assert.rejects(start({ maxQueue: 1.5 }), { code: 'ERR_OUT_OF_RANGE' });
|
|
398
|
+
await assert.rejects(start({ maxQueue: 'x' }), { code: 'ERR_INVALID_ARG_TYPE' });
|
|
399
|
+
});
|
|
400
|
+
test('watch("/") receives events for files under root #293', async () => {
|
|
401
|
+
const env_9 = { stack: [], error: void 0, hasError: false };
|
|
299
402
|
try {
|
|
300
403
|
// Regression: emitChange previously exited its parent-walk before
|
|
301
404
|
// checking watchers.get('/'), so a watcher registered on '/' never fired.
|
|
302
405
|
const { promise, resolve } = Promise.withResolvers();
|
|
303
|
-
const watcher = __addDisposableResource(
|
|
406
|
+
const watcher = __addDisposableResource(env_9, fs.watch('/', (eventType, filename) => {
|
|
304
407
|
resolve([eventType, filename]);
|
|
305
408
|
}), false);
|
|
306
409
|
await fs.promises.writeFile('/watch-root-file.txt', 'x');
|
|
@@ -309,12 +412,34 @@ suite('Watch', config('watch'), () => {
|
|
|
309
412
|
assert.equal(eventType, 'rename');
|
|
310
413
|
assert.equal(filename, 'watch-root-file.txt');
|
|
311
414
|
}
|
|
312
|
-
catch (
|
|
313
|
-
|
|
314
|
-
|
|
415
|
+
catch (e_9) {
|
|
416
|
+
env_9.error = e_9;
|
|
417
|
+
env_9.hasError = true;
|
|
315
418
|
}
|
|
316
419
|
finally {
|
|
317
|
-
__disposeResources(
|
|
420
|
+
__disposeResources(env_9);
|
|
318
421
|
}
|
|
319
422
|
});
|
|
423
|
+
test('Watching a missing path throws ENOENT', async () => {
|
|
424
|
+
const path = '/watch-missing/file.txt';
|
|
425
|
+
const expected = { code: 'ENOENT', syscall: 'watch', path, filename: path, message: `ENOENT: no such file or directory, watch '${path}'` };
|
|
426
|
+
assert.throws(() => fs.watch(path), expected);
|
|
427
|
+
const iterator = fs.promises.watch(path);
|
|
428
|
+
await assert.rejects(iterator.next(), expected);
|
|
429
|
+
});
|
|
430
|
+
test('Aborting the signal closes the watcher', async () => {
|
|
431
|
+
const controller = new AbortController();
|
|
432
|
+
const watcher = fs.watch(testFile, { signal: controller.signal });
|
|
433
|
+
let closes = 0;
|
|
434
|
+
watcher.on('close', () => closes++);
|
|
435
|
+
controller.abort();
|
|
436
|
+
watcher.close();
|
|
437
|
+
await new Promise(resolve => setTimeout(resolve, 0));
|
|
438
|
+
assert.equal(closes, 1);
|
|
439
|
+
const preAborted = fs.watch(testFile, { signal: AbortSignal.abort() });
|
|
440
|
+
let isSync = true;
|
|
441
|
+
const closed = new Promise(resolve => preAborted.on('close', () => resolve(isSync)));
|
|
442
|
+
isSync = false;
|
|
443
|
+
assert.equal(await closed, false);
|
|
444
|
+
});
|
|
320
445
|
});
|
|
@@ -1,5 +1,58 @@
|
|
|
1
|
+
var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
|
|
2
|
+
if (value !== null && value !== void 0) {
|
|
3
|
+
if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
|
|
4
|
+
var dispose, inner;
|
|
5
|
+
if (async) {
|
|
6
|
+
if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
|
|
7
|
+
dispose = value[Symbol.asyncDispose];
|
|
8
|
+
}
|
|
9
|
+
if (dispose === void 0) {
|
|
10
|
+
if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
|
|
11
|
+
dispose = value[Symbol.dispose];
|
|
12
|
+
if (async) inner = dispose;
|
|
13
|
+
}
|
|
14
|
+
if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
|
|
15
|
+
if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
|
|
16
|
+
env.stack.push({ value: value, dispose: dispose, async: async });
|
|
17
|
+
}
|
|
18
|
+
else if (async) {
|
|
19
|
+
env.stack.push({ async: true });
|
|
20
|
+
}
|
|
21
|
+
return value;
|
|
22
|
+
};
|
|
23
|
+
var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
|
|
24
|
+
return function (env) {
|
|
25
|
+
function fail(e) {
|
|
26
|
+
env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
|
|
27
|
+
env.hasError = true;
|
|
28
|
+
}
|
|
29
|
+
var r, s = 0;
|
|
30
|
+
function next() {
|
|
31
|
+
while (r = env.stack.pop()) {
|
|
32
|
+
try {
|
|
33
|
+
if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
|
|
34
|
+
if (r.dispose) {
|
|
35
|
+
var result = r.dispose.call(r.value);
|
|
36
|
+
if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
|
|
37
|
+
}
|
|
38
|
+
else s |= 1;
|
|
39
|
+
}
|
|
40
|
+
catch (e) {
|
|
41
|
+
fail(e);
|
|
42
|
+
}
|
|
43
|
+
}
|
|
44
|
+
if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
|
|
45
|
+
if (env.hasError) throw env.error;
|
|
46
|
+
}
|
|
47
|
+
return next();
|
|
48
|
+
};
|
|
49
|
+
})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
|
|
50
|
+
var e = new Error(message);
|
|
51
|
+
return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
|
|
52
|
+
});
|
|
1
53
|
// SPDX-License-Identifier: LGPL-3.0-or-later
|
|
2
54
|
import assert from 'node:assert/strict';
|
|
55
|
+
import { Readable } from 'node:stream';
|
|
3
56
|
import { readFileSync } from 'node:fs';
|
|
4
57
|
import { join } from 'node:path/posix';
|
|
5
58
|
import { suite, test } from 'node:test';
|
|
@@ -80,4 +133,133 @@ suite('Writes', config('write'), () => {
|
|
|
80
133
|
assert.equal(fs.statSync(file).mode & 0o777, mode);
|
|
81
134
|
fs.unlinkSync(file);
|
|
82
135
|
});
|
|
136
|
+
test('writeSync with an options object', config('sync'), () => {
|
|
137
|
+
const file = 'write-options-sync.txt';
|
|
138
|
+
const fd = fs.openSync(file, 'w+');
|
|
139
|
+
assert.equal(fs.writeSync(fd, Buffer.from('abcdef'), { offset: 1, length: 2 }), 2);
|
|
140
|
+
assert.equal(fs.writeSync(fd, Buffer.from('xyz')), 3);
|
|
141
|
+
fs.closeSync(fd);
|
|
142
|
+
assert.equal(fs.readFileSync(file, 'utf8'), 'bcxyz');
|
|
143
|
+
fs.unlinkSync(file);
|
|
144
|
+
});
|
|
145
|
+
test('write with an options object', config('async'), async () => {
|
|
146
|
+
const file = 'write-options.txt';
|
|
147
|
+
const fd = fs.openSync(file, 'w+');
|
|
148
|
+
const buffer = Buffer.from('abcdef');
|
|
149
|
+
const { promise, resolve, reject } = Promise.withResolvers();
|
|
150
|
+
fs.write(fd, buffer, { offset: 1, length: 2, position: 0 }, (error, written, result) => error ? reject(error) : resolve([written, result]));
|
|
151
|
+
const [written, result] = await promise;
|
|
152
|
+
assert.equal(written, 2);
|
|
153
|
+
assert.equal(result, buffer);
|
|
154
|
+
fs.closeSync(fd);
|
|
155
|
+
assert.equal(fs.readFileSync(file, 'utf8'), 'bc');
|
|
156
|
+
fs.unlinkSync(file);
|
|
157
|
+
});
|
|
158
|
+
test('Positional writes do not move the file position', config('sync'), async () => {
|
|
159
|
+
const env_1 = { stack: [], error: void 0, hasError: false };
|
|
160
|
+
try {
|
|
161
|
+
const file = 'write-positional.txt';
|
|
162
|
+
const fd = fs.openSync(file, 'w+');
|
|
163
|
+
fs.writeSync(fd, 'abc');
|
|
164
|
+
fs.writeSync(fd, 'X', 0);
|
|
165
|
+
fs.writeSync(fd, 'def');
|
|
166
|
+
assert.equal(fs.readFileSync(file, 'utf8'), 'Xbcdef');
|
|
167
|
+
const handle = __addDisposableResource(env_1, await fs.promises.open(file, 'r+'), true);
|
|
168
|
+
await handle.write('1');
|
|
169
|
+
await handle.write('Y', 4);
|
|
170
|
+
await handle.write('2');
|
|
171
|
+
assert.equal(fs.readFileSync(file, 'utf8'), '12cdYf');
|
|
172
|
+
fs.closeSync(fd);
|
|
173
|
+
fs.unlinkSync(file);
|
|
174
|
+
}
|
|
175
|
+
catch (e_1) {
|
|
176
|
+
env_1.error = e_1;
|
|
177
|
+
env_1.hasError = true;
|
|
178
|
+
}
|
|
179
|
+
finally {
|
|
180
|
+
const result_1 = __disposeResources(env_1);
|
|
181
|
+
if (result_1)
|
|
182
|
+
await result_1;
|
|
183
|
+
}
|
|
184
|
+
});
|
|
185
|
+
test('writevSync writes at the current position and respects views', config('sync'), () => {
|
|
186
|
+
const file = 'write-vectored.txt';
|
|
187
|
+
const fd = fs.openSync(file, 'w+');
|
|
188
|
+
const bytes = Buffer.from('xxabcxx');
|
|
189
|
+
assert.equal(fs.writevSync(fd, [bytes.subarray(2, 5), Buffer.from('de')]), 5);
|
|
190
|
+
assert.equal(fs.writevSync(fd, [Buffer.from('f')]), 1);
|
|
191
|
+
assert.equal(fs.writevSync(fd, [Buffer.from('A')], 0), 1);
|
|
192
|
+
assert.equal(fs.writevSync(fd, [Buffer.from('g')]), 1);
|
|
193
|
+
fs.closeSync(fd);
|
|
194
|
+
assert.equal(fs.readFileSync(file, 'utf8'), 'Abcdefg');
|
|
195
|
+
fs.unlinkSync(file);
|
|
196
|
+
});
|
|
197
|
+
test('Objects are not coerced to strings', async () => {
|
|
198
|
+
const env_2 = { stack: [], error: void 0, hasError: false };
|
|
199
|
+
try {
|
|
200
|
+
const object = { toString: () => 'x' };
|
|
201
|
+
const error = { name: 'TypeError', code: 'ERR_INVALID_ARG_TYPE' };
|
|
202
|
+
const file = 'write-coercion.txt';
|
|
203
|
+
assert.throws(() => fs.writeFileSync(file, object), error);
|
|
204
|
+
assert.throws(() => fs.appendFileSync(file, object), error);
|
|
205
|
+
await assert.rejects(fs.promises.writeFile(file, object), error);
|
|
206
|
+
await assert.rejects(fs.promises.appendFile(file, object), error);
|
|
207
|
+
const handle = __addDisposableResource(env_2, await fs.promises.open(file, 'a+'), true);
|
|
208
|
+
await assert.rejects(handle.write(object), error);
|
|
209
|
+
await assert.rejects(handle.writeFile(object), error);
|
|
210
|
+
await assert.rejects(handle.appendFile(object), error);
|
|
211
|
+
assert.throws(() => fs.writeSync(handle.fd, object), error);
|
|
212
|
+
assert.throws(() => fs.write(handle.fd, object, () => { }), error);
|
|
213
|
+
assert.equal(fs.readFileSync(file, 'utf8'), '');
|
|
214
|
+
fs.unlinkSync(file);
|
|
215
|
+
}
|
|
216
|
+
catch (e_2) {
|
|
217
|
+
env_2.error = e_2;
|
|
218
|
+
env_2.hasError = true;
|
|
219
|
+
}
|
|
220
|
+
finally {
|
|
221
|
+
const result_2 = __disposeResources(env_2);
|
|
222
|
+
if (result_2)
|
|
223
|
+
await result_2;
|
|
224
|
+
}
|
|
225
|
+
});
|
|
226
|
+
test('Non-byte views are written by byte length', async () => {
|
|
227
|
+
const file = 'write-view.txt';
|
|
228
|
+
const view = new Uint16Array([0x6261, 0x6463]);
|
|
229
|
+
fs.writeFileSync(file, view);
|
|
230
|
+
assert.equal(fs.readFileSync(file, 'latin1'), 'abcd');
|
|
231
|
+
await fs.promises.writeFile(file, new DataView(view.buffer));
|
|
232
|
+
assert.equal(fs.readFileSync(file, 'latin1'), 'abcd');
|
|
233
|
+
fs.unlinkSync(file);
|
|
234
|
+
});
|
|
235
|
+
test('writeFile and appendFile write iterables', async () => {
|
|
236
|
+
const env_3 = { stack: [], error: void 0, hasError: false };
|
|
237
|
+
try {
|
|
238
|
+
const path = 'write-iterable.txt';
|
|
239
|
+
await fs.promises.writeFile(path, ['a', Buffer.from('b'), new Uint8Array([99])]);
|
|
240
|
+
assert.equal(fs.readFileSync(path, 'utf8'), 'abc');
|
|
241
|
+
await fs.promises.writeFile(path, (async function* () {
|
|
242
|
+
yield 'd';
|
|
243
|
+
yield Buffer.from('e');
|
|
244
|
+
})());
|
|
245
|
+
assert.equal(fs.readFileSync(path, 'utf8'), 'de');
|
|
246
|
+
await fs.promises.writeFile(path, ['6869'], { encoding: 'hex' });
|
|
247
|
+
assert.equal(fs.readFileSync(path, 'utf8'), 'hi');
|
|
248
|
+
await fs.promises.appendFile(path, Readable.from(['!', '?']));
|
|
249
|
+
assert.equal(fs.readFileSync(path, 'utf8'), 'hi!?');
|
|
250
|
+
const handle = __addDisposableResource(env_3, await fs.promises.open(path, 'w'), true);
|
|
251
|
+
await handle.writeFile(Readable.from([Buffer.from('xy'), 'z']));
|
|
252
|
+
assert.equal(fs.readFileSync(path, 'utf8'), 'xyz');
|
|
253
|
+
await assert.rejects(fs.promises.writeFile(path, [1]), { code: 'ERR_INVALID_ARG_TYPE' });
|
|
254
|
+
}
|
|
255
|
+
catch (e_3) {
|
|
256
|
+
env_3.error = e_3;
|
|
257
|
+
env_3.hasError = true;
|
|
258
|
+
}
|
|
259
|
+
finally {
|
|
260
|
+
const result_3 = __disposeResources(env_3);
|
|
261
|
+
if (result_3)
|
|
262
|
+
await result_3;
|
|
263
|
+
}
|
|
264
|
+
});
|
|
83
265
|
});
|
package/package.json
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
1
|
{
|
|
2
2
|
"name": "@zenfs/devel",
|
|
3
|
-
"version": "
|
|
3
|
+
"version": "1.1.0",
|
|
4
4
|
"description": "Tooling for developing ZenFS packages",
|
|
5
5
|
"funding": {
|
|
6
6
|
"type": "individual",
|
|
@@ -14,6 +14,7 @@
|
|
|
14
14
|
],
|
|
15
15
|
"bin": {
|
|
16
16
|
"make-index": "dist/bin/make-index.js",
|
|
17
|
+
"node-compat": "dist/bin/node-compat.js",
|
|
17
18
|
"zenfs-test": "dist/bin/zenfs-test.js",
|
|
18
19
|
"zci": "dist/bin/zci.js"
|
|
19
20
|
},
|
|
@@ -34,10 +35,12 @@
|
|
|
34
35
|
"url": "https://github.com/zen-fs/devel/issues"
|
|
35
36
|
},
|
|
36
37
|
"engines": {
|
|
37
|
-
"node": ">=
|
|
38
|
+
"node": ">= 24"
|
|
38
39
|
},
|
|
39
40
|
"exports": {
|
|
40
41
|
"./eslint": "./eslint.shared.js",
|
|
42
|
+
".": "./dist/index.js",
|
|
43
|
+
"./node_compat": "./dist/node_compat.js",
|
|
41
44
|
"./*": "./dist/*.js"
|
|
42
45
|
},
|
|
43
46
|
"publishConfig": {
|
|
@@ -60,10 +63,11 @@
|
|
|
60
63
|
"@octokit/action": "^8.0.4",
|
|
61
64
|
"buffer": "^6.0.3",
|
|
62
65
|
"c8": "^12.0.0",
|
|
66
|
+
"commander": "^15.0.0",
|
|
63
67
|
"globals": "^17.3.0",
|
|
64
68
|
"kerium": "^1.5.0",
|
|
65
69
|
"typescript-eslint": "^8.58.0",
|
|
66
|
-
"utilium": "^3.
|
|
70
|
+
"utilium": "^3.11.0"
|
|
67
71
|
},
|
|
68
72
|
"peerDependencies": {
|
|
69
73
|
"@zenfs/core": "^2.8.0",
|
|
@@ -75,6 +79,7 @@
|
|
|
75
79
|
}
|
|
76
80
|
},
|
|
77
81
|
"devDependencies": {
|
|
82
|
+
"@commander-js/extra-typings": "^15.0.0",
|
|
78
83
|
"@types/node": "^26.0.0",
|
|
79
84
|
"@zenfs/core": "^2.8.0",
|
|
80
85
|
"eslint": "^10.1.0",
|