@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.
Files changed (52) hide show
  1. package/dist/bin/make-index.js +37 -74
  2. package/dist/bin/node-compat.d.ts +2 -0
  3. package/dist/bin/node-compat.js +340 -0
  4. package/dist/bin/zci.js +33 -44
  5. package/dist/bin/zenfs-test.js +45 -78
  6. package/dist/index.d.ts +1 -0
  7. package/dist/index.js +1 -0
  8. package/dist/make_index.d.ts +20 -0
  9. package/dist/make_index.js +49 -0
  10. package/dist/node_compat/analysis.d.ts +53 -0
  11. package/dist/node_compat/analysis.js +60 -0
  12. package/dist/node_compat/changelog.d.ts +25 -0
  13. package/dist/node_compat/changelog.js +60 -0
  14. package/dist/node_compat/commits.d.ts +26 -0
  15. package/dist/node_compat/commits.js +66 -0
  16. package/dist/node_compat/config.d.ts +6 -0
  17. package/dist/node_compat/config.js +18 -0
  18. package/dist/node_compat/docs.d.ts +58 -0
  19. package/dist/node_compat/docs.js +213 -0
  20. package/dist/node_compat/git.d.ts +22 -0
  21. package/dist/node_compat/git.js +74 -0
  22. package/dist/node_compat/index.d.ts +10 -0
  23. package/dist/node_compat/index.js +11 -0
  24. package/dist/node_compat/node.d.ts +42 -0
  25. package/dist/node_compat/node.js +84 -0
  26. package/dist/node_compat/output.d.ts +29 -0
  27. package/dist/node_compat/output.js +95 -0
  28. package/dist/node_compat/pr.d.ts +59 -0
  29. package/dist/node_compat/pr.js +125 -0
  30. package/dist/node_compat/state.d.ts +18 -0
  31. package/dist/node_compat/state.js +12 -0
  32. package/dist/node_compat/versions.d.ts +5 -0
  33. package/dist/node_compat/versions.js +13 -0
  34. package/dist/node_compat/zenfs.d.ts +3 -0
  35. package/dist/node_compat/zenfs.js +108 -0
  36. package/dist/tests/fs/callbacks.test.d.ts +1 -0
  37. package/dist/tests/fs/callbacks.test.js +41 -0
  38. package/dist/tests/fs/cp.test.d.ts +1 -0
  39. package/dist/tests/fs/cp.test.js +186 -0
  40. package/dist/tests/fs/dir.test.js +40 -0
  41. package/dist/tests/fs/directory.test.js +42 -0
  42. package/dist/tests/fs/links.test.js +36 -0
  43. package/dist/tests/fs/open.test.js +15 -0
  44. package/dist/tests/fs/read.test.js +139 -2
  45. package/dist/tests/fs/readFile.test.js +159 -0
  46. package/dist/tests/fs/stat.test.js +67 -0
  47. package/dist/tests/fs/streams.test.js +178 -0
  48. package/dist/tests/fs/tempdir.test.js +8 -0
  49. package/dist/tests/fs/truncate.test.js +89 -0
  50. package/dist/tests/fs/watch.test.js +131 -6
  51. package/dist/tests/fs/write.test.js +182 -0
  52. 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('watch("/") receives events for files under root #293', async () => {
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(env_7, fs.watch('/', (eventType, filename) => {
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 (e_7) {
313
- env_7.error = e_7;
314
- env_7.hasError = true;
415
+ catch (e_9) {
416
+ env_9.error = e_9;
417
+ env_9.hasError = true;
315
418
  }
316
419
  finally {
317
- __disposeResources(env_7);
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": "0.1.0",
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": ">= 22"
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.7.0"
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",