refactor

package-lock.json

@@ -11,26 +11,19 @@
         "mime": "^4.1.0"
       },
       "devDependencies": {
-        "@sugoidogo/web-filesystem-types": "^2.0.0",
+        "@sugoidogo/importable-types-web": "^1.0.0",
         "@types/node": "^25.0.9",
         "typescript": "^5.9.3"
       }
     },
-    "node_modules/@sugoidogo/node-web-globals": {
+    "node_modules/@sugoidogo/importable-types-web": {
       "version": "1.0.0",
-      "resolved": "https://gitea.sugoidogo.com/api/packages/sugoidogo/npm/%40sugoidogo%2Fnode-web-globals/-/1.0.0/node-web-globals-1.0.0.tgz",
+      "resolved": "https://gitea.sugoidogo.com/api/packages/sugoidogo/npm/%40sugoidogo%2Fimportable-types-web/-/1.0.0/importable-types-web-1.0.0.tgz",
-      "integrity": "sha512-mE2yB2h2Vg8I+0zkcFHLUZgH+dbpb03e5Zwn+cDeXFRnj/nb/mLCIxXc9OeKUSH06PYyOGtH76XKKwGzey9TnA==",
+      "integrity": "sha512-MqWkQ/WsllO7GiQjqWiFB3ZzsDwJwGPXIWkyd0E24d3CMcI0FKGgsOn6G/RVjCO9k2d/aRlzxqVmyuPAYOZ8tQ==",
-      "dev": true,
-      "license": "MIT"
-    },
-    "node_modules/@sugoidogo/web-filesystem-types": {
-      "version": "2.0.0",
-      "resolved": "https://gitea.sugoidogo.com/api/packages/sugoidogo/npm/%40sugoidogo%2Fweb-filesystem-types/-/2.0.0/web-filesystem-types-2.0.0.tgz",
-      "integrity": "sha512-ET5F+WlqNZnskgbSACG1flLAKftJBehLPiQgRtUotuh2+pSqIGrHHQT5KC2v6b5/3LM47K1Zjm8GFcJpmXEjmw==",
       "dev": true,
       "license": "Apache-2.0",
       "dependencies": {
-        "@sugoidogo/node-web-globals": "^1.0.0"
+        "undici-types": "^7.16.0"
       }
     },
     "node_modules/@types/node": {

package.json

@@ -16,7 +16,7 @@
     "mime": "^4.1.0"
   },
   "devDependencies": {
-    "@sugoidogo/web-filesystem-types": "^2.0.0",
+    "@sugoidogo/importable-types-web": "^1.0.0",
     "@types/node": "^25.0.9",
     "typescript": "^5.9.3"
   }

scripts/test.ts

@@ -1,14 +1,21 @@
-import NodeFileSystemDirectoryHandle from '../dist/NodeFileSystemDirectoryHandle.js'
+import NodeFileSystemDirectoryHandle from '../src/NodeFileSystemDirectoryHandle.ts'
 
+const textText="Hello World!"
 const cwd_directory_handle = new NodeFileSystemDirectoryHandle('.')
-const test_directory_handle=await cwd_directory_handle.getDirectoryHandle('test',{'create':true})
+const test_directory_handle = await cwd_directory_handle.getDirectoryHandle('test', { 'create': true })
-const file_handle = await test_directory_handle.getFileHandle('test.txt', { 'create': true })
+for (let i = 0; i < 10000; i++) {
-const writable = await file_handle.createWritable()
+    const file_handle = await test_directory_handle.getFileHandle(i+'.txt', { 'create': true })
-writable.write('Hello World!')
+    let writable = await file_handle.createWritable()
-writable.close()
+    await writable.write(textText+textText)
-const file = await file_handle.getFile()
+    await writable.close()
-console.log(file.type)
+    writable = await file_handle.createWritable()
-console.log(await file.text())
+    await writable.write(textText)
+    await writable.close()
+    const file = await file_handle.getFile()
+    console.log(file.webkitRelativePath)
+    const text = await file.text()
+    if (text !== textText) throw new Error("failed to read back written data")
+}
 const result = await cwd_directory_handle.getFileHandle('test/test.txt').catch(error => 'blocked path traversal')
 if (typeof result === 'string') console.log(result)
 else console.error('path traversal not blocked')

src/NodeFileSystemDirectoryHandle.ts

@@ -1,25 +1,36 @@
 import * as fs from 'node:fs';
 import * as asyncfs from 'node:fs/promises';
-import * as path from 'node:path';
+import * as Path from 'node:path';
 import NodeFileSystemHandle from './NodeFileSystemHandle.ts';
 import NodeFileSystemFileHandle from './NodeFileSystemFileHandle.ts';
+import type {
+    FileSystemDirectoryHandle,
+    FileSystemGetDirectoryOptions,
+    FileSystemDirectoryHandleAsyncIterator,
+    FileSystemGetFileOptions,
+    FileSystemRemoveOptions,
+    FileSystemHandle
+} from '@sugoidogo/importable-types-web'
 
 export default class NodeFileSystemDirectoryHandle extends NodeFileSystemHandle implements FileSystemDirectoryHandle {
     declare kind: "directory";
-    constructor(fpath: string, options: FileSystemGetDirectoryOptions = {}) {
+    constructor(path: string, options: FileSystemGetDirectoryOptions & { origin?: NodeFileSystemDirectoryHandle } = {}) {
-        super()
+        super(path, options)
-        fpath = path.normalize(fpath)
+        try {
-        if (!fs.existsSync(fpath) && options.create) fs.mkdirSync(fpath)
+            const stats = fs.statSync(this.path)
-        if (!fs.lstatSync(fpath).isDirectory()) throw new Error('not a directory')
+            if (!stats.isDirectory()) throw new Error("tried to open file as directory: " + this.path)
-        this.path = fpath
+        } catch (error) {
+            if (options.create) fs.mkdirSync(this.path)
+            else throw error
+        }
     }
     entries(): FileSystemDirectoryHandleAsyncIterator<[string, NodeFileSystemDirectoryHandle | NodeFileSystemFileHandle]> {
         const entries: Array<[string, NodeFileSystemDirectoryHandle | NodeFileSystemFileHandle]> = []
         fs.readdirSync(this.path).forEach(name => {
             if (fs.lstatSync(name).isDirectory()) {
-                entries.push([name, new NodeFileSystemDirectoryHandle(path.join(this.path, name))])
+                entries.push([name, new NodeFileSystemDirectoryHandle(Path.join(this.path, name), { origin: this.origin || this })])
             } else {
-                entries.push([name, new NodeFileSystemFileHandle(path.join(this.path, name))])
+                entries.push([name, new NodeFileSystemFileHandle(Path.join(this.path, name), { origin: this.origin || this })])
             }
         })
         return entries[Symbol.asyncIterator]
@@ -31,37 +42,33 @@ export default class NodeFileSystemDirectoryHandle extends NodeFileSystemHandle
         const values: Array<NodeFileSystemDirectoryHandle | NodeFileSystemFileHandle> = [];
         fs.readdirSync(this.path).forEach(name => {
             if (fs.lstatSync(name).isDirectory()) {
-                values.push(new NodeFileSystemDirectoryHandle(path.join(this.path, name)))
+                values.push(new NodeFileSystemDirectoryHandle(Path.join(this.path, name), { origin: this.origin || this }))
             } else {
-                values.push(new NodeFileSystemFileHandle(path.join(this.path, name)))
+                values.push(new NodeFileSystemFileHandle(Path.join(this.path, name), { origin: this.origin || this }))
             }
         })
         return values[Symbol.asyncIterator]
     }
     #getValidatedPath(name: string) {
-        name = path.normalize(name)
+        name = Path.normalize(name)
-        if (name.includes(path.sep)) throw new TypeError('Invalid Filename')
+        if (name.includes(Path.sep)) throw new TypeError('Invalid Filename')
-        return path.join(this.path, name)
+        return Path.join(this.path, name)
     }
     async getDirectoryHandle(name: string, options: FileSystemGetDirectoryOptions = {}): Promise<NodeFileSystemDirectoryHandle> {
+        Object.assign(options, { origin: this.origin || this })
         return new NodeFileSystemDirectoryHandle(this.#getValidatedPath(name), options)
     }
     async getFileHandle(name: string, options: FileSystemGetFileOptions = {}): Promise<NodeFileSystemFileHandle> {
+        Object.assign(options, { origin: this.origin || this })
         return new NodeFileSystemFileHandle(this.#getValidatedPath(name), options)
     }
     async removeEntry(name: string, options: FileSystemRemoveOptions = { recursive: false }): Promise<void> {
         return asyncfs.rm(this.#getValidatedPath(name), { recursive: options.recursive, force: options.recursive })
     }
     async resolve(possibleDescendant: FileSystemHandle): Promise<string[] | null> {
-        if (typeof possibleDescendant !== typeof this) return null
+        if (!(possibleDescendant instanceof NodeFileSystemHandle)) return null
-        let thisName = this.path
+        if (!possibleDescendant.path.startsWith(this.path)) return null
-        let possibleDescendantName = possibleDescendant.name
+        return possibleDescendant.path.substring(this.path.length + 1).split(Path.sep)
-        if (!path.isAbsolute(this.path)) thisName = path.join(process.cwd(), this.path)
-        if (!path.isAbsolute(possibleDescendant.name)) possibleDescendantName = path.join(process.cwd(), possibleDescendant.name)
-        if (!possibleDescendantName.startsWith(thisName)) return null
-        possibleDescendantName = possibleDescendantName.substring(thisName.length - 1)
-        if (possibleDescendantName[0] == path.sep) possibleDescendantName = possibleDescendantName.substring(1)
-        return possibleDescendantName.split(path.sep)
     }
     [Symbol.asyncIterator] = this.entries
 }

src/NodeFileSystemFileHandle.ts

@@ -1,29 +1,40 @@
 import * as fs from 'node:fs';
 import * as asyncfs from 'node:fs/promises';
-import * as path from 'node:path';
+import * as Path from "node:path"
 import NodeFileSystemHandle from './NodeFileSystemHandle.ts';
 import NodeFileSystemWritableFileStream from './NodeFileSystemWriteableFileStream.ts';
 import mime from 'mime'
+import type {
+    FileSystemFileHandle,
+    FileSystemGetFileOptions,
+    FileSystemCreateWritableOptions,
+    FileSystemWritableFileStream,
+    File as WebFile
+} from '@sugoidogo/importable-types-web'
+import type NodeFileSystemDirectoryHandle from './NodeFileSystemDirectoryHandle.ts';
 
 export default class NodeFileSystemFileHandle extends NodeFileSystemHandle implements FileSystemFileHandle {
     declare kind: "file";
-    constructor(fpath: string, options: FileSystemGetFileOptions={}) {
+    constructor(path: string, options: FileSystemGetFileOptions & { origin?: NodeFileSystemDirectoryHandle } = {}) {
-        super()
+        super(path,options)
-        fpath = path.normalize(fpath)
+        let flags = fs.constants.O_RDWR
-        if (!fs.existsSync(fpath) && options.create) fs.writeFileSync(fpath, '')
+        if (options.create) flags |= fs.constants.O_CREAT
-        if (fs.lstatSync(fpath).isDirectory()) new Error('not a file')
+        fs.closeSync(fs.openSync(this.path, flags))
-        this.path = fpath
     }
     async createWritable(options: FileSystemCreateWritableOptions = {}): Promise<FileSystemWritableFileStream> {
-        return new NodeFileSystemWritableFileStream(this.path,options)
+        let flags = fs.constants.O_WRONLY
+        const fileHandle = await asyncfs.open(this.path, flags)
+        if (!options.keepExistingData) await fileHandle.truncate(0)
+        return new NodeFileSystemWritableFileStream(fileHandle)
     }
-    async getFile(): Promise<File> {
+    async getFile(): Promise<WebFile> {
+        const type = mime.getType(this.path.split('.').pop())
         const stats = await asyncfs.stat(this.path)
-        const type = mime.getType(this.name.split('.').pop())
+        const relativePathSegments = await this.origin.resolve(this)
-        return asyncfs.readFile(this.path).then(buffer => Object.assign(new Blob([buffer],{type}), {
+        return Object.assign(await fs.openAsBlob(this.path, { "type": type }), {
-            lastModified: stats.mtimeMs,
+            name: this.name,
-            name: this.path,
+            webkitRelativePath: relativePathSegments.join(Path.sep),
-            webkitRelativePath: this.path
+            lastModified: stats.mtimeMs
-        }))
+        }) as any
     }
 }

src/NodeFileSystemHandle.ts

@@ -1,15 +1,22 @@
-import * as path from 'node:path'
+import * as Path from 'node:path'
+import type {
+    FileSystemHandle,
+    FileSystemHandleKind
+} from '@sugoidogo/importable-types-web'
+import type NodeFileSystemDirectoryHandle from './NodeFileSystemDirectoryHandle';
 
 export default class NodeFileSystemHandle implements FileSystemHandle {
     kind: FileSystemHandleKind;
     path: string;
-    get name() { return path.basename(this.path) }
+    origin: NodeFileSystemDirectoryHandle
+    get name() { return Path.basename(this.path) }
+    constructor(path: string, options: { origin?: NodeFileSystemDirectoryHandle } = {}) {
+        if (!Path.isAbsolute(path)) path = Path.resolve(path)
+        this.path = path
+        this.origin = options.origin
+    }
     async isSameEntry(other: FileSystemHandle): Promise<boolean> {
-        if (typeof other != typeof this) return false
+        if (!(other instanceof NodeFileSystemHandle)) return false
-        let thisName = this.name
+        return this.path === other.path
-        let otherName = other.name
-        if (!path.isAbsolute(this.name)) thisName = path.join(process.cwd(), this.name)
-        if (!path.isAbsolute(other.name)) otherName = path.join(process.cwd(), other.name)
-        return thisName === otherName
     }
 }

src/NodeFileSystemWriteableFileStream.ts

@@ -1,38 +1,44 @@
-import * as fs from 'node:fs'
-import * as asyncfs from 'node:fs/promises'
-import * as path from 'node:path'
 import { Writable } from 'node:stream'
+import type {
+    FileSystemWritableFileStream,
+    FileSystemWriteChunkType,
+    WriteParams
+} from '@sugoidogo/importable-types-web'
+import type { FileHandle } from 'node:fs/promises'
+
+function isWriteParams(data: FileSystemWriteChunkType): data is WriteParams {
+    return ["write", "seek", "truncate"].includes((data as WriteParams).type)
+}
 
 export default class NodeFileSystemWritableFileStream extends WritableStream implements FileSystemWritableFileStream {
-    #seek_position = 0
+    #position = 0
-    #name: string
+    #fileHandle: FileHandle
-    constructor(name: string, options: FileSystemCreateWritableOptions={}) {
+    constructor(fileHandle: FileHandle) {
-        name = path.normalize(name)
+        const writeStream = fileHandle.createWriteStream({ "encoding": "binary" })
-        super(Writable.toWeb(fs.createWriteStream(name)))
+        const writeableStream = Writable.toWeb(writeStream)
-        this.#name = name
+        super(writeableStream)
-        if(!options.keepExistingData) this.truncate(0)
+        this.#fileHandle = fileHandle
     }
     async seek(position: number): Promise<void> {
-        this.#seek_position = position
+        if (this.locked) throw new Error("stream is locked")
+        this.#position = position
     }
-    truncate(size: number): Promise<void> {
+    async truncate(size: number): Promise<void> {
-        return asyncfs.truncate(this.#name, size)
+        if (this.locked) throw new Error("stream is locked")
+        return this.#fileHandle.truncate(size)
     }
-    async write(wdata: FileSystemWriteChunkType): Promise<void> {
+    async write(data: FileSystemWriteChunkType): Promise<void> {
-        if (wdata instanceof Blob) wdata = await wdata.bytes()
+        if (this.locked) throw new Error("stream is locked")
-        if (typeof wdata === 'string') wdata = new TextEncoder().encode(wdata)
+        let offset: number, length: number, position=this.#position
-        let wsize: number = null
+        if (isWriteParams(data)) {
-        let pseek_position = this.#seek_position
+            if (data.type === "seek") return this.seek(data.position)
-        if ((wdata as WriteParams).type) {
+            if (data.type === "truncate") return this.truncate(data.size)
-            const { type, position, size, data } = (wdata as WriteParams)
+            if (typeof data.position === "number") position = data.position
-            if (type === 'truncate') return asyncfs.truncate(this.#name, size)
+            length = data.size
-            if (position) this.#seek_position = position
+            data = data.data
-            if (type === 'seek') return
-            if (size) wsize = size
-            wdata = data
         }
-        const file = await asyncfs.open(this.#name,'r+')
+        if (typeof data === 'string') data = new TextEncoder().encode(data)
-        await file.write((wdata as Uint8Array), null, wsize, this.#seek_position)
+        const { bytesWritten } = await this.#fileHandle.write(data as any, offset, length, position)
-        this.#seek_position = pseek_position
+        this.#position=position+bytesWritten
     }
 }

tsconfig.json

@@ -3,10 +3,6 @@
         "target": "es2022",
         "module": "es2022",
         "lib": ["ES2022"],
-        "types": [
-            "node",
-            "@sugoidogo/web-filesystem-types"
-        ],
         "moduleResolution": "node",
         "sourceMap": true,
         "declaration": true,