@zenfs/core 2.4.1 → 2.4.3

package/tests/fs/dir.test.ts

@@ -1,7 +1,8 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
+import { sync, type Dirent } from '@zenfs/core';
 import assert, { rejects } from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { fs, type Dirent } from '../common.js';
+import { fs } from '../common.js';
 
 const testFile = 'test-file.txt';
 fs.writeFileSync(testFile, 'Sample content');
@@ -13,48 +14,7 @@ fs.mkdirSync(testDirPath);
 for (const file of testFiles) {
 	fs.writeFileSync(`${testDirPath}/${file}`, 'Sample content');
 }
-
-suite('Dirent', () => {
-	test('name and parentPath getters', async () => {
-		const stats = await fs.promises.lstat(testFile);
-		const dirent = fs.Dirent.from(testFile, stats);
-
-		assert.equal(dirent.name, testFile);
-		assert.equal(dirent.parentPath, '.');
-	});
-
-	test('isFile', async () => {
-		const fileStats = await fs.promises.lstat(testFile);
-		const fileDirent = fs.Dirent.from(testFile, fileStats);
-
-		assert(fileDirent.isFile());
-		assert(!fileDirent.isDirectory());
-	});
-
-	test('isDirectory', async () => {
-		const dirStats = await fs.promises.lstat('test-directory');
-		const dirDirent = fs.Dirent.from('test-directory', dirStats);
-
-		assert(!dirDirent.isFile());
-		assert(dirDirent.isDirectory());
-	});
-
-	test('isSymbolicLink', async () => {
-		const symlinkStats = await fs.promises.lstat('test-symlink');
-		const symlinkDirent = fs.Dirent.from('test-symlink', symlinkStats);
-
-		assert(symlinkDirent.isSymbolicLink());
-	});
-
-	test('other methods return false', async () => {
-		const fileStats = await fs.promises.lstat(testFile);
-		const fileDirent = fs.Dirent.from(testFile, fileStats);
-
-		assert(!fileDirent.isBlockDevice());
-		assert(!fileDirent.isCharacterDevice());
-		assert(!fileDirent.isSocket());
-	});
-});
+await sync();
 
 suite('Dir', () => {
 	test('read()', async () => {

package/tests/fs/directory.test.ts

@@ -29,7 +29,7 @@ suite('Directories', () => {
 	test('mkdirSync', async () => await fs.promises.mkdir('/two', 0o000));
 
 	test('mkdir, nested', async () => {
-		await assert.rejects(fs.promises.mkdir('/nested/dir'), { code: 'ENOENT', path: '/nested' });
+		await assert.rejects(fs.promises.mkdir('/nested/dir'), { code: 'ENOENT', path: '/nested/dir' });
 		assert(!(await fs.promises.exists('/nested/dir')));
 	});
 
@@ -148,9 +148,9 @@ suite('Directories', () => {
 		entries.sort((a, b) => join(a.parentPath, a.name).localeCompare(join(b.parentPath, b.name)));
 		const values = entries.map(entry => [entry.parentPath, entry.name]);
 
-		assert.deepEqual(values[0], [testDir, 'file1.txt']);
-		assert.deepEqual(values[4], [join(testDir, 'subdir1'), 'file4.txt']);
-		assert.deepEqual(values[8], [join(testDir, 'subdir2'), 'file5.txt']);
+		assert.deepEqual(values[0], ['.', 'file1.txt']);
+		assert.deepEqual(values[4], ['subdir1', 'file4.txt']);
+		assert.deepEqual(values[8], ['subdir2', 'file5.txt']);
 	});
 
 	test('readdirSync returns files recursively', () => {

package/tests/fs/errors.test.ts

@@ -20,7 +20,7 @@ suite('Error messages', () => {
 	test('open', async () => await assert.rejects(() => fs.promises.open(path, 'r'), missing));
 	test('readdir', async () => await assert.rejects(() => fs.promises.readdir(path), missing));
 	test('unlink', async () => await assert.rejects(() => fs.promises.unlink(path), missing));
-	test('link', async () => await assert.rejects(() => fs.promises.link(path, 'foo'), missing));
+	test('link', async () => await assert.rejects(() => fs.promises.link(path, 'foo'), { code: 'ENOENT', path: '/foo' }));
 	test('chmod', async () => await assert.rejects(() => fs.promises.chmod(path, 0o666), missing));
 	test('lstat', async () => await assert.rejects(() => fs.promises.lstat(path), missing));
 	test('readlink', async () => await assert.rejects(() => fs.promises.readlink(path), missing));
@@ -32,7 +32,7 @@ suite('Error messages', () => {
 	test('openSync', () => assert.throws(() => fs.openSync(path, 'r'), missing));
 	test('readdirSync', () => assert.throws(() => fs.readdirSync(path), missing));
 	test('unlinkSync', () => assert.throws(() => fs.unlinkSync(path), missing));
-	test('linkSync', () => assert.throws(() => fs.linkSync(path, 'foo'), missing));
+	test('linkSync', () => assert.throws(() => fs.linkSync(path, 'foo'), { code: 'ENOENT', path: '/foo' }));
 	test('chmodSync', () => assert.throws(() => fs.chmodSync(path, 0o666), missing));
 	test('lstatSync', () => assert.throws(() => fs.lstatSync(path), missing));
 	test('readlinkSync', () => assert.throws(() => fs.readlinkSync(path), missing));

package/tests/fs/links.test.ts

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
+import { join } from '@zenfs/core/path';
 import type { Exception } from 'kerium';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { join } from '../../dist/path.js';
 import { fs } from '../common.js';
 
 suite('Links', () => {

package/tests/fs/permissions.test.ts

@@ -3,9 +3,9 @@ import { Exception } from 'kerium';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
 import { encodeUTF8 } from 'utilium';
-import { defaultContext } from '../../dist/internal/contexts.js';
-import { join } from '../../dist/path.js';
-import { R_OK, W_OK, X_OK } from '../../dist/vfs/constants.js';
+import { defaultContext } from '@zenfs/core/internal/contexts.js';
+import { join } from '@zenfs/core/path';
+import { R_OK, W_OK, X_OK } from '@zenfs/core/constants';
 import { fs } from '../common.js';
 
 const asyncMode = 0o777;

package/tests/fs/read.test.ts

@@ -1,10 +1,10 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
+import { sync } from '@zenfs/core';
 import { Buffer } from 'buffer';
 import assert from 'node:assert/strict';
 import type { OpenMode, PathLike } from 'node:fs';
 import { suite, test } from 'node:test';
 import { promisify } from 'node:util';
-import { sync } from '../../dist/config.js';
 import { fs } from '../common.js';
 
 const filepath = 'x.txt';

package/tests/fs/scaling.test.ts

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
+import { sync } from '@zenfs/core';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { sync } from '../../dist/config.js';
 import { fs } from '../common.js';
 
 const n_files = 130;

package/tests/fs/stat.test.ts

@@ -1,8 +1,7 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
+import { defaultContext, Stats } from '@zenfs/core';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { defaultContext } from '../../dist/internal/contexts.js';
-import { Stats } from '../../dist/vfs/stats.js';
 import { fs } from '../common.js';
 
 suite('Stats', () => {

package/tests/fs/times.test.ts

@@ -1,9 +1,9 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
+import type { StatsLike } from '@zenfs/core';
 import { Exception } from 'kerium';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
 import { wait } from 'utilium';
-import type { StatsLike } from '../../dist/vfs/stats.js';
 import { fs } from '../common.js';
 
 const path = 'x.txt';

package/tests/fs/watch.test.ts

@@ -1,7 +1,8 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
+import type { Stats } from '@zenfs/core';
 import assert from 'node:assert/strict';
 import { suite, test } from 'node:test';
-import { fs, type Stats } from '../common.js';
+import { fs } from '../common.js';
 
 const testDir = '/test-watch-dir';
 const testFile = testDir + '/test.txt';
@@ -12,7 +13,7 @@ await fs.promises.writeFile(testFile, 'Initial content');
 /**
  * @todo convert `using watcher = ...` to void discards pending ES proposal
  */
-suite('Watch', async () => {
+suite('Watch', () => {
 	test('Events emitted on file change', async () => {
 		const { promise, resolve } = Promise.withResolvers<[string, string]>();
 

package/tests/setup/context.ts

@@ -1,5 +1,4 @@
-import { bindContext } from '../../dist/context.js';
-import { fs as _fs } from '../../dist/index.js';
+import { fs as _fs, bindContext } from '@zenfs/core';
 import { copySync, data } from '../setup.js';
 
 _fs.mkdirSync('/new_root');

package/tests/setup/cow.ts

@@ -1,4 +1,4 @@
-import { configureSingle, InMemory, CopyOnWrite, resolveMountConfig, fs } from '../../dist/index.js';
+import { configureSingle, CopyOnWrite, fs, InMemory, resolveMountConfig } from '@zenfs/core';
 import { copySync, data } from '../setup.js';
 
 fs.umount('/');

package/tests/setup/index.ts

@@ -1,7 +1,7 @@
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path/posix';
-import { configureSingle, CopyOnWrite, InMemory, InMemoryStore, mounts, Readonly, StoreFS } from '../../dist/index.js';
-import { S_IFDIR } from '../../dist/vfs/constants.js';
+import { configureSingle, CopyOnWrite, InMemory, InMemoryStore, mounts, Readonly, StoreFS } from '@zenfs/core';
+import { S_IFDIR } from '@zenfs/core/constants';
 import { copySync, data } from '../setup.js';
 
 copySync(data);

package/tests/setup/port.ts

@@ -1,6 +1,6 @@
+import { InMemory, Port, configureSingle, fs, resolveMountConfig, resolveRemoteMount, sync } from '@zenfs/core';
 import { after, afterEach } from 'node:test';
 import { MessageChannel } from 'node:worker_threads';
-import { InMemory, Port, configureSingle, fs, resolveMountConfig, resolveRemoteMount, sync } from '../../dist/index.js';
 import { copySync, data } from '../setup.js';
 
 const { port1: localPort, port2: remotePort } = new MessageChannel();

package/tests/setup/single-buffer.ts

@@ -1,4 +1,4 @@
-import { SingleBuffer, configureSingle } from '../../dist/index.js';
+import { SingleBuffer, configureSingle } from '@zenfs/core';
 import { copySync, data } from '../setup.js';
 
 await configureSingle({

package/tests/setup.ts

@@ -1,7 +1,8 @@
 // SPDX-License-Identifier: LGPL-3.0-or-later
+import { fs as _fs } from '@zenfs/core';
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync } from 'node:fs';
 import { join, relative } from 'node:path';
-import { fs as _fs } from '../dist/index.js';
+import type { NodeFS } from '@zenfs/core/node/types.js';
 
 export const data = join(import.meta.dirname, 'data');
 
@@ -9,7 +10,7 @@ export const tmp = join(import.meta.dirname, 'tmp');
 
 if (!existsSync(tmp)) mkdirSync(tmp);
 
-export async function copyAsync(_path: string, fs: typeof _fs = _fs): Promise<void> {
+export async function copyAsync(_path: string, fs: NodeFS = _fs): Promise<void> {
 	const path = relative(data, _path) || '/';
 	const stats = statSync(_path);
 
@@ -26,7 +27,7 @@ export async function copyAsync(_path: string, fs: typeof _fs = _fs): Promise<vo
 	}
 }
 
-export function copySync(_path: string, fs: typeof _fs = _fs): void {
+export function copySync(_path: string, fs: NodeFS = _fs): void {
 	const path = relative(data, _path) || '/';
 	const stats = statSync(_path);
 

package/dist/vfs/types.d.ts

@@ -1,24 +0,0 @@
-import type * as fs from 'node:fs';
-export type FileContents = ArrayBufferView | string;
-/**
- * @internal @hidden Used for the internal `_open` functions
- */
-export interface OpenOptions {
-    flag: fs.OpenMode;
-    mode?: fs.Mode | null;
-    /**
-     * If true, do not resolve symlinks
-     */
-    preserveSymlinks?: boolean;
-    /**
-     * If true, allows opening directories
-     */
-    allowDirectory?: boolean;
-}
-export type ReaddirOptions = {
-    withFileTypes?: boolean;
-    recursive?: boolean;
-    encoding?: BufferEncoding | 'buffer' | null;
-} | BufferEncoding | 'buffer' | null;
-/** Helper union @hidden */
-export type GlobOptionsU = fs.GlobOptionsWithFileTypes | fs.GlobOptionsWithoutFileTypes | fs.GlobOptions;

package/tests/assignment.ts

@@ -1,21 +0,0 @@
-// SPDX-License-Identifier: LGPL-3.0-or-later
-/* eslint-disable @typescript-eslint/no-unused-vars */
-
-/*
-	This test assigns the exported fs module from ZenFS with the one exported from Node.
-	This ensures anything new that is added will be caught
-
-	Notes on omissions and exclusions:
-	- __promisify__ is omitted as it is metadata
-	- native is omitted as zenfs isn't native
-	- ReadStream and WriteStream are excluded since they are polyfilled from another module
-*/
-
-import type * as node from 'node:fs';
-import { fs as zen } from '../src/index.js';
-
-type Mock = {
-	[K in Exclude<keyof typeof node, 'ReadStream' | 'WriteStream'>]: Omit<(typeof node)[K], '__promisify__' | 'native'>;
-};
-
-const _module: Mock = zen;