@zenfs/core 1.4.0 → 1.4.2

package/dist/backends/file_index.d.ts

@@ -42,23 +42,7 @@ export declare class Index extends Map<string, Stats> {
      */
     static parse(data: string): Index;
 }
-declare const IndexFS_base: import("../index.js").Mixin<typeof FileSystem, {
-    metadata(): import("../filesystem.js").FileSystemMetadata;
-    rename(oldPath: string, newPath: string): Promise<void>;
-    renameSync(oldPath: string, newPath: string): void;
-    createFile(path: string, flag: string, mode: number): Promise<import("../file.js").File>;
-    createFileSync(path: string, flag: string, mode: number): import("../file.js").File;
-    unlink(path: string): Promise<void>;
-    unlinkSync(path: string): void;
-    rmdir(path: string): Promise<void>;
-    rmdirSync(path: string): void;
-    mkdir(path: string, mode: number): Promise<void>;
-    mkdirSync(path: string, mode: number): void;
-    link(srcpath: string, dstpath: string): Promise<void>;
-    linkSync(srcpath: string, dstpath: string): void;
-    sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
-    syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
-}>;
+declare const IndexFS_base: import("../index.js").Mixin<typeof FileSystem, import("../mixins/readonly.js").ReadonlyMixin>;
 export declare abstract class IndexFS extends IndexFS_base {
     private indexData;
     protected index: Index;

package/dist/backends/port/fs.d.ts

@@ -3,7 +3,6 @@ import type { ExtractProperties } from 'utilium';
 import { type MountConfiguration } from '../../config.js';
 import { File } from '../../file.js';
 import { FileSystem, type FileSystemMetadata } from '../../filesystem.js';
-import { Async } from '../../mixins/async.js';
 import { Stats } from '../../stats.js';
 import type { Backend, FilesystemOf } from '../backend.js';
 import * as RPC from './rpc.js';
@@ -51,7 +50,7 @@ export interface FSRequest<TMethod extends FSMethod = FSMethod> extends RPC.Requ
     method: TMethod;
     args: Parameters<FSMethods[TMethod]>;
 }
-declare const PortFS_base: import("../../index.js").Mixin<typeof FileSystem, Async>;
+declare const PortFS_base: import("../../index.js").Mixin<typeof FileSystem, import("../../mixins/async.js").AsyncMixin>;
 /**
  * PortFS lets you access an FS instance that is running in a port, or the other way around.
  *

package/dist/context.d.ts

@@ -25,7 +25,7 @@ export interface BoundContext extends Fn_FS, FSContext {
 }
 /**
  * Allows you to restrict operations to a specific root path and set of credentials.
- * Note that the credentials of a bound context are copied.
+ * Note that the default credentials of a bound context are copied from the global credentials.
  * @experimental
  */
 export declare function bindContext(root: string, credentials?: CredentialInit): BoundContext;

package/dist/context.js

@@ -9,7 +9,7 @@ function _bindFunctions(fns, thisValue) {
 }
 /**
  * Allows you to restrict operations to a specific root path and set of credentials.
- * Note that the credentials of a bound context are copied.
+ * Note that the default credentials of a bound context are copied from the global credentials.
  * @experimental
  */
 export function bindContext(root, credentials = structuredClone(defaultCredentials)) {

package/dist/mixins/async.d.ts

@@ -9,7 +9,7 @@ export type AsyncOperation = {
 /**
  * @internal
  */
-export interface Async {
+export interface AsyncMixin {
     /**
      * @internal @protected
      */
@@ -37,5 +37,5 @@ export interface Async {
  * During loading, the contents of the async file system are preloaded into the synchronous store.
  *
  */
-export declare function Async<const T extends typeof FileSystem>(FS: T): Mixin<T, Async>;
-export declare function asyncPatch<T extends typeof FileSystem>(fs: Mixin<T, Async>): void;
+export declare function Async<const T extends typeof FileSystem>(FS: T): Mixin<T, AsyncMixin>;
+export declare function asyncPatch<T extends typeof FileSystem>(fs: Mixin<T, AsyncMixin>): void;

package/dist/mixins/readonly.d.ts

@@ -3,9 +3,9 @@ import type { FileSystem, FileSystemMetadata } from '../filesystem.js';
 import type { Stats } from '../stats.js';
 import type { Mixin } from './shared.js';
 /**
- * Implements the non-readonly methods to throw `EROFS`
+ * @internal
  */
-export declare function Readonly<T extends typeof FileSystem>(FS: T): Mixin<T, {
+export interface ReadonlyMixin {
     metadata(): FileSystemMetadata;
     rename(oldPath: string, newPath: string): Promise<void>;
     renameSync(oldPath: string, newPath: string): void;
@@ -21,4 +21,8 @@ export declare function Readonly<T extends typeof FileSystem>(FS: T): Mixin<T, {
     linkSync(srcpath: string, dstpath: string): void;
     sync(path: string, data: Uint8Array, stats: Readonly<Stats>): Promise<void>;
     syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
-}>;
+}
+/**
+ * Implements the non-readonly methods to throw `EROFS`
+ */
+export declare function Readonly<T extends typeof FileSystem>(FS: T): Mixin<T, ReadonlyMixin>;

package/dist/polyfills.js

@@ -9,11 +9,6 @@ Promise.withResolvers ?? (Promise.withResolvers = function () {
     });
     return { promise, resolve: _resolve, reject: _reject };
 });
-/*
-    A polyfill for when these symbols are undefined.
-    For some reason, NodeJS does not polyfill them in a VM context.
-    Since jest uses a VM context for ESM, these need to be here.
-*/
 // @ts-expect-error 2540
 Symbol['dispose'] ?? (Symbol['dispose'] = Symbol('Symbol.dispose'));
 // @ts-expect-error 2540

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/core",
-	"version": "1.4.0",
+	"version": "1.4.2",
 	"description": "A filesystem, anywhere",
 	"funding": {
 		"type": "individual",

package/readme.md

@@ -9,13 +9,13 @@ It works using a system of backends, which are used by ZenFS to store and retrie
 ZenFS is modular and extensible. The core includes some built-in backends:
 
 -   `InMemory`: Stores files in-memory. This is cleared when the runtime ends (e.g. a user navigating away from a web page or a Node process exiting)
--   `Overlay`: Use read-only file system as read-write by overlaying a writable file system on top of it. ([copy-on-write](https://en.wikipedia.org/wiki/Copy-on-write))
+-   `Overlay`: Use a read-only file system as read-write by overlaying a writable file system on top of it. ([copy-on-write](https://en.wikipedia.org/wiki/Copy-on-write))
 -   `Fetch`: Downloads files over HTTP with the `fetch` API (_readonly_)
 -   `Port`: Interacts with a remote over a `MessagePort`-like interface (e.g. a worker)
 
 ZenFS supports a number of other backends. Many are provided as separate packages under `@zenfs`. More backends can be defined by separate libraries by extending the `FileSystem` class and providing a `Backend` object.
 
-You can find all of the packages available over at [zenfs.dev](https://zenfs.dev).
+You can find all of the packages available over on [NPM](https://www.npmjs.com/org/zenfs).
 
 As an added bonus, all ZenFS backends support synchronous operations. All of the backends included with the core are cross-platform.
 
@@ -51,7 +51,7 @@ The following example mounts a zip file to `/zip`, in-memory storage to `/tmp`,
 ```js
 import { configure, InMemory } from '@zenfs/core';
 import { IndexedDB } from '@zenfs/dom';
-import { Zip } from '@zenfs/zip';
+import { Zip } from '@zenfs/archives';
 
 const res = await fetch('mydata.zip');
 
@@ -122,7 +122,7 @@ You can then mount and unmount the backend instance by using `mount` and `umount
 ```js
 import { configure, resolveMountConfig, InMemory } from '@zenfs/core';
 import { IndexedDB } from '@zenfs/dom';
-import { Zip } from '@zenfs/zip';
+import { Zip } from '@zenfs/archives';
 
 await configure({
 	mounts: {

package/scripts/test.js

@@ -15,6 +15,7 @@ const { values: options, positionals } = parseArgs({
 		auto: { short: 'a', type: 'boolean', default: false },
 		build: { short: 'b', type: 'boolean', default: false },
 		common: { short: 'c', type: 'boolean', default: false },
+		coverage: { type: 'string', default: 'tests/.coverage' },
 	},
 	allowPositionals: true,
 });
@@ -62,7 +63,7 @@ if (options.auto) {
 	let sum = 0;
 
 	for (const pattern of ['**/tests/setup/*.ts', '**/tests/setup-*.ts']) {
-		const files = await globSync(pattern);
+		const files = await globSync(pattern).filter(f => !f.includes('node_modules'));
 		sum += files.length;
 		positionals.push(...files);
 	}
@@ -70,15 +71,14 @@ if (options.auto) {
 	!options.quiet && console.log(`Auto-detected ${sum} test setup files`);
 }
 
-const coverage = join(import.meta.dirname, '../.coverage');
-if (existsSync(coverage)) rmSync(coverage, { recursive: true });
-mkdirSync(coverage);
-process.env.NODE_V8_COVERAGE = coverage;
+if (existsSync(options.coverage)) rmSync(options.coverage, { recursive: true });
+mkdirSync(options.coverage);
+process.env.NODE_V8_COVERAGE = options.coverage;
 
 if (options.common) {
 	!options.quiet && console.log('Running common tests...');
 	try {
-		execSync("tsx --test --experimental-test-coverage 'tests/**/!(fs)/*.test.ts'", {
+		execSync("tsx --test --experimental-test-coverage 'tests/*.test.ts' 'tests/**/!(fs)/*.test.ts'", {
 			stdio: ['ignore', options.verbose ? 'inherit' : 'ignore', 'inherit'],
 		});
 	} catch {
@@ -107,4 +107,4 @@ for (const setupFile of positionals) {
 }
 
 execSync('npx c8 report --reporter=text', { stdio: 'inherit' });
-rmSync('.coverage', { recursive: true });
+rmSync(options.coverage, { recursive: true });