@zenfs/dom 1.1.1 → 1.1.3

package/dist/access.d.ts

@@ -1,4 +1,4 @@
-import type { FileSystemMetadata } from '@zenfs/core';
+import type { CreationOptions, FileSystemMetadata } from '@zenfs/core';
 import { FileSystem, PreloadFile, Stats } from '@zenfs/core';
 export interface WebAccessOptions {
     handle: FileSystemDirectoryHandle;
@@ -21,7 +21,7 @@ export declare class WebAccessFS extends WebAccessFS_base {
     unlink(path: string): Promise<void>;
     link(srcpath: string): Promise<void>;
     rmdir(path: string): Promise<void>;
-    mkdir(path: string): Promise<void>;
+    mkdir(path: string, mode?: number, options?: CreationOptions): Promise<void>;
     readdir(path: string): Promise<string[]>;
     protected getHandle(path: string): Promise<FileSystemHandle | undefined>;
 }

package/dist/access.js

@@ -1,6 +1,5 @@
-import { Async, Errno, ErrnoError, FileSystem, InMemory, PreloadFile, Stats } from '@zenfs/core';
-import { S_IFDIR, S_IFREG } from '@zenfs/core/emulation/constants.js';
-import { basename, dirname, join } from '@zenfs/core/emulation/path.js';
+import { Async, constants, Errno, ErrnoError, FileSystem, InMemory, PreloadFile, Stats } from '@zenfs/core';
+import { basename, dirname, join } from '@zenfs/core/vfs/path.js';
 import { convertException } from './utils.js';
 function isResizable(buffer) {
     if (buffer instanceof ArrayBuffer)
@@ -24,6 +23,8 @@ export class WebAccessFS extends Async(FileSystem) {
             ...super.metadata(),
             name: 'WebAccess',
             noResizableBuffers: true,
+            // Not really, but we don't support opening directories so this prevent the VFS from trying
+            features: ['setid'],
         };
     }
     async sync(path, data) {
@@ -84,11 +85,11 @@ export class WebAccessFS extends Async(FileSystem) {
             throw ErrnoError.With('ENOENT', path, 'stat');
         }
         if (handle instanceof FileSystemDirectoryHandle) {
-            return new Stats({ mode: 0o777 | S_IFDIR, size: 4096 });
+            return new Stats({ mode: 0o777 | constants.S_IFDIR, size: 4096 });
         }
         if (handle instanceof FileSystemFileHandle) {
             const { lastModified, size } = await handle.getFile();
-            return new Stats({ mode: 0o777 | S_IFREG, size, mtimeMs: lastModified });
+            return new Stats({ mode: 0o777 | constants.S_IFREG, size, mtimeMs: lastModified });
         }
         throw new ErrnoError(Errno.EBADE, 'Handle is not a directory or file', path, 'stat');
     }
@@ -101,7 +102,7 @@ export class WebAccessFS extends Async(FileSystem) {
             throw convertException(ex, path, 'openFile');
         });
         const data = new Uint8Array(await file.arrayBuffer());
-        const stats = new Stats({ mode: 0o777 | S_IFREG, size: file.size, mtimeMs: file.lastModified });
+        const stats = new Stats({ mode: 0o777 | constants.S_IFREG, size: file.size, mtimeMs: file.lastModified });
         return new PreloadFile(this, path, flag, stats, data);
     }
     async unlink(path) {
@@ -120,7 +121,7 @@ export class WebAccessFS extends Async(FileSystem) {
     async rmdir(path) {
         return this.unlink(path);
     }
-    async mkdir(path) {
+    async mkdir(path, mode, options) {
         const existingHandle = await this.getHandle(path).catch((ex) => {
             if (ex.code != 'ENOENT') {
                 throw ex;

package/dist/xml.d.ts

@@ -1,4 +1,4 @@
-import type { File, StatsLike } from '@zenfs/core';
+import type { CreationOptions, File, FileSystemMetadata, StatsLike } from '@zenfs/core';
 import { FileSystem, Stats } from '@zenfs/core';
 export interface XMLOptions {
     /**
@@ -6,7 +6,7 @@ export interface XMLOptions {
      */
     root?: Element;
 }
-declare const XMLFS_base: import("@zenfs/core").Mixin<typeof FileSystem, import("utilium").ExtractProperties<FileSystem, (...args: any[]) => Promise<unknown>>>;
+declare const XMLFS_base: import("@zenfs/core").Mixin<typeof FileSystem, import("@zenfs/core").AsyncFSMethods>;
 export declare class XMLFS extends XMLFS_base {
     /**
      * @inheritdoc XMLOptions.root
@@ -17,19 +17,20 @@ export declare class XMLFS extends XMLFS_base {
      * @inheritdoc XMLOptions.root
      */
     root?: Element);
+    metadata(): FileSystemMetadata;
     renameSync(oldPath: string, newPath: string): void;
     statSync(path: string): Stats;
     openFileSync(path: string, flag: string): File;
-    createFileSync(path: string, flag: string, mode: number): File;
+    createFileSync(path: string, flag: string, mode: number, { uid, gid }: CreationOptions): File;
     unlinkSync(path: string): void;
     rmdirSync(path: string): void;
-    mkdirSync(path: string, mode: number): void;
+    mkdirSync(path: string, mode: number, { uid, gid }: CreationOptions): void;
     readdirSync(path: string): string[];
     linkSync(target: string, link: string): void;
     syncSync(path: string, data: Uint8Array, stats: Readonly<Stats>): void;
     toString(): string;
     protected get(syscall: string, path: string): Element;
-    protected create(syscall: string, path: string, stats?: Partial<StatsLike<number>>): Element;
+    protected create(syscall: string, path: string, stats: Partial<StatsLike<number>> & Pick<StatsLike, 'mode'>): Element;
     protected add(syscall: string, node: Element, path: string, contents?: boolean): void;
     protected remove(syscall: string, node: Element, path: string, contents?: boolean): void;
 }

package/dist/xml.js

@@ -1,6 +1,5 @@
-import { decodeRaw, encodeRaw, Errno, ErrnoError, FileSystem, PreloadFile, Stats, Sync } from '@zenfs/core';
-import { S_IFDIR, S_IFREG } from '@zenfs/core/emulation/constants.js';
-import { basename, dirname } from '@zenfs/core/path';
+import { constants, decodeRaw, encodeRaw, Errno, ErrnoError, FileSystem, PreloadFile, Stats, Sync } from '@zenfs/core';
+import { basename, dirname } from '@zenfs/core/vfs/path.js';
 const statsLikeKeys = ['size', 'mode', 'atimeMs', 'mtimeMs', 'ctimeMs', 'birthtimeMs', 'uid', 'gid', 'ino', 'nlink'];
 function get_stats(node) {
     const stats = {};
@@ -37,7 +36,7 @@ export class XMLFS extends Sync(FileSystem) {
         super();
         this.root = root;
         try {
-            this.mkdirSync('/', 0o777);
+            this.mkdirSync('/', 0o777, { uid: 0, gid: 0 });
         }
         catch (e) {
             const error = e;
@@ -45,6 +44,9 @@ export class XMLFS extends Sync(FileSystem) {
                 throw error;
         }
     }
+    metadata() {
+        return { ...super.metadata(), features: ['setid'] };
+    }
     renameSync(oldPath, newPath) {
         const node = this.get('rename', oldPath);
         this.remove('rename', node, oldPath);
@@ -57,8 +59,13 @@ export class XMLFS extends Sync(FileSystem) {
         const node = this.get('openFile', path);
         return new PreloadFile(this, path, flag, get_stats(node), encodeRaw(node.textContent));
     }
-    createFileSync(path, flag, mode) {
-        const stats = new Stats({ mode: mode | S_IFREG });
+    createFileSync(path, flag, mode, { uid, gid }) {
+        const parent = this.statSync(dirname(path));
+        const stats = new Stats({
+            mode: mode | constants.S_IFREG,
+            uid: parent.mode & constants.S_ISUID ? parent.uid : uid,
+            gid: parent.mode & constants.S_ISGID ? parent.gid : gid,
+        });
         this.create('createFile', path, stats);
         return new PreloadFile(this, path, flag, stats);
     }
@@ -76,8 +83,13 @@ export class XMLFS extends Sync(FileSystem) {
             throw ErrnoError.With('ENOTDIR', path, 'rmdir');
         this.remove('rmdir', node, path);
     }
-    mkdirSync(path, mode) {
-        const node = this.create('mkdir', path, { mode: mode | S_IFDIR });
+    mkdirSync(path, mode, { uid, gid }) {
+        const parent = this.statSync(dirname(path));
+        const node = this.create('mkdir', path, {
+            mode: mode | constants.S_IFDIR,
+            uid: parent.mode & constants.S_ISUID ? parent.uid : uid,
+            gid: parent.mode & constants.S_ISGID ? parent.gid : gid,
+        });
         node.textContent = '[]';
     }
     readdirSync(path) {
@@ -113,12 +125,15 @@ export class XMLFS extends Sync(FileSystem) {
         }
         throw ErrnoError.With('ENOENT', path, syscall);
     }
-    create(syscall, path, stats = {}) {
+    create(syscall, path, stats) {
         if (this.existsSync(path))
             throw ErrnoError.With('EEXIST', path, syscall);
         const node = document.createElement('file');
         this.add(syscall, node, path);
-        set_stats(node, new Stats(stats));
+        set_stats(node, new Stats({
+            ...stats,
+            uid: stats.mode,
+        }));
         this.root.append(node);
         return node;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zenfs/dom",
-	"version": "1.1.1",
+	"version": "1.1.3",
 	"description": "DOM backends for ZenFS",
 	"funding": {
 		"type": "individual",
@@ -19,6 +19,10 @@
 		"type": "git",
 		"url": "git+https://github.com/zen-fs/dom.git"
 	},
+	"publishConfig": {
+		"access": "public",
+		"provenance": true
+	},
 	"bugs": {
 		"url": "https://github.com/zen-fs/dom/issues"
 	},
@@ -57,7 +61,7 @@
 		"typescript-eslint": "^8.8.1"
 	},
 	"peerDependencies": {
-		"@zenfs/core": "^1.6.4"
+		"@zenfs/core": "^1.7.0"
 	},
 	"keywords": [
 		"filesystem",