feat: new way of creating temporary files backed up by fs

from.js

@@ -1,11 +1,20 @@
-import { statSync, createReadStream, promises as fs } from 'node:fs'
-import { basename } from 'node:path'
+import {
+  realpathSync,
+  statSync,
+  rmdirSync,
+  createReadStream,
+  promises as fs
+} from 'node:fs'
+import { basename, sep, join } from 'node:path'
+import { tmpdir } from 'node:os'
+import process from 'node:process'
 import DOMException from 'node-domexception'
 
 import File from './file.js'
 import Blob from './index.js'
 
-const { stat } = fs
+const { stat, mkdtemp } = fs
+let i = 0, tempDir, registry
 
 /**
  * @param {string} path filepath on the disk
@@ -49,6 +58,42 @@ const fromFile = (stat, path, type = '') => new File([new BlobDataItem({
   start: 0
 })], basename(path), { type, lastModified: stat.mtimeMs })
 
+/**
+ * Creates a temporary blob backed by the filesystem.
+ * NOTE: requires node.js v14 or higher to use FinalizationRegistry
+ *
+ * @param {*} data Same as fs.writeFile data
+ * @param {string} [type] mimetype to use
+ * @param {AbortSignal} [signal] in case you wish to cancel the write operation
+ * @returns {Promise<Blob>}
+ */
+const createTemporaryBlob = async (data, type, signal) => {
+  registry = registry || new FinalizationRegistry(fs.unlink)
+  tempDir = tempDir || await mkdtemp(realpathSync(tmpdir()) + sep)
+  const id = `${i++}`
+  const destination = join(tempDir, id)
+  if (data instanceof ArrayBuffer) data = new Uint8Array(data)
+  await fs.writeFile(destination, data, { signal })
+  const blob = await blobFrom(destination, type)
+  registry.register(blob, destination)
+  return blob
+}
+
+/**
+ * Creates a temporary File backed by the filesystem.
+ * Pretty much the same as constructing a new File(data, name, options)
+ *
+ * NOTE: requires node.js v14 or higher to use FinalizationRegistry
+ * @param {*} data
+ * @param {string} name
+ * @param {FilePropertyBag & {signal?: AbortSignal}} opts
+ * @returns {Promise<File>}
+ */
+const createTemporaryFile = async (data, name, opts) => {
+  const blob = await createTemporaryBlob(data)
+  return new File([blob], name, opts)
+}
+
 /**
  * This is a blob backed up by a file on the disk
  * with minium requirement. Its wrapped around a Blob as a blobPart
@@ -102,5 +147,18 @@ class BlobDataItem {
   }
 }
 
+process.once('exit', () => {
+  tempDir && rmdirSync(tempDir, { recursive: true })
+})
+
 export default blobFromSync
-export { File, Blob, blobFrom, blobFromSync, fileFrom, fileFromSync }
+export {
+  Blob,
+  blobFrom,
+  blobFromSync,
+  createTemporaryBlob,
+  File,
+  fileFrom,
+  fileFromSync,
+  createTemporaryFile
+}

test/own-misc-test.js

@@ -3,7 +3,14 @@
 
 import fs from 'node:fs'
 import buffer from 'node:buffer'
-import syncBlob, { blobFromSync, blobFrom, fileFromSync, fileFrom } from '../from.js'
+import syncBlob, {
+  blobFromSync,
+  blobFrom,
+  fileFromSync,
+  fileFrom,
+  createTemporaryBlob,
+  createTemporaryFile
+} from '../from.js'
 
 const license = fs.readFileSync('./LICENSE')
 
@@ -189,6 +196,38 @@ promise_test(async () => {
   assert_equals(await (await fileFrom('./LICENSE')).text(), license.toString())
 }, 'blob part backed up by filesystem slice correctly')
 
+promise_test(async () => {
+  let blob
+  // Can construct a temporary blob from a string
+  blob = await createTemporaryBlob(license.toString())
+  assert_equals(await blob.text(), license.toString())
+
+  // Can construct a temporary blob from a async iterator
+  blob = await createTemporaryBlob(blob.stream())
+  assert_equals(await blob.text(), license.toString())
+
+  // Can construct a temporary file from a arrayBuffer
+  blob = await createTemporaryBlob(await blob.arrayBuffer())
+  assert_equals(await blob.text(), license.toString())
+
+  // Can construct a temporary file from a arrayBufferView
+  blob = await createTemporaryBlob(await blob.arrayBuffer().then(ab => new Uint8Array(ab)))
+  assert_equals(await blob.text(), license.toString())
+
+  // Can specify a mime type
+  blob = await createTemporaryBlob('abc', 'text/plain')
+  assert_equals(blob.type, 'text/plain')
+
+  // Can create files too
+  let file = await createTemporaryFile('abc', 'abc.txt', {
+    type: 'text/plain',
+    lastModified: 123
+  })
+  assert_equals(file.name, 'abc.txt')
+  assert_equals(file.size, 3)
+  assert_equals(file.lastModified, 123)
+}, 'creating temporary blob/file backed up by filesystem')
+
 promise_test(async () => {
   fs.writeFileSync('temp', '')
   await blobFromSync('./temp').text()