chore: migrate to spa

scripts/errors.ts

@@ -0,0 +1,38 @@
+export function rejectIfError<E = unknown>(error: E | undefined, reject: (error?: E) => void, handler?: (error?: E) => void) {
+  if (error) {
+    reject(error)
+    !!handler && handler(error)
+  }
+}
+
+export function resolveWhenNoError<R = void, E = unknown>(reject: (error?: E) => void, resolve: (result?: R) => void) {
+  return (err?: E) => {
+    if (err) {
+      reject(err)
+    }
+    else {
+      resolve()
+    }
+  }
+}
+
+export function onError<E = unknown>(reject: (error?: E) => void, handler?: (error?: E) => void) {
+  return (error?: E) => rejectIfError(error, reject, handler)
+}
+
+export function noError<
+  T,
+  U extends unknown[],
+  E = unknown,
+>(
+  reject: (err?: E) => void,
+  fn: (...args: U) => T,
+): (err: E | undefined, ...args: U) => T | undefined {
+  return (err, ...args) => {
+    if (err) {
+      rejectIfError(err, reject)
+      return
+    }
+    return fn(...args)
+  }
+}

scripts/fs.ts

@@ -0,0 +1,25 @@
+import { stat } from 'node:fs/promises'
+
+export async function exists(path: string) {
+  try {
+    await stat(path)
+    return true
+  }
+  catch (error) {
+    if (isENOENTError(error))
+      return false
+
+    throw error
+  }
+}
+
+export function isENOENTError(error: unknown): boolean {
+  if (!(error instanceof Error))
+    return false
+  if (!('code' in error))
+    return false
+  if (error.code !== 'ENOENT')
+    return false
+
+  return true
+}

scripts/unzip.ts

@@ -0,0 +1,80 @@
+import type { Buffer } from 'node:buffer'
+import { createWriteStream, existsSync, mkdirSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fromBuffer } from 'yauzl'
+import { noError, onError, resolveWhenNoError } from './errors'
+
+/**
+ * Example:
+ *
+ * await unzip("./tim.zip", "./");
+ *
+ * Will create directories:
+ *
+ * ./tim.zip
+ * ./tim
+ *
+ * Originally by [How to unzip to a folder using yauzl? - Stack Overflow](https://stackoverflow.com/questions/63932027/how-to-unzip-to-a-folder-using-yauzl)
+ *
+ * @param buffer Buffer of the zip file.
+ * @param target Path to the folder where the zip folder will be put.
+ */
+export async function unzip(buffer: Buffer, target: string) {
+  return new Promise<void>((resolve, reject) => {
+    let pendingWrites = 0
+
+    fromBuffer(buffer, { lazyEntries: true }, noError(reject, (zipFile) => {
+      // This is the key. We start by reading the first entry.
+      zipFile.readEntry()
+
+      // Now for every entry, we will write a file or dir
+      // to disk. Then call zipFile.readEntry() again to
+      // trigger the next cycle.
+      zipFile.on('entry', (entry) => {
+        // Directories
+        if (/\/$/.test(entry.fileName)) {
+          // Create the directory then read the next entry.
+          mkdirSync(join(target, entry.fileName), { recursive: true })
+          zipFile.readEntry()
+
+          return
+        }
+
+        // Files
+        const dir = dirname(join(target, entry.fileName))
+        if (!existsSync(dir)) {
+          mkdirSync(dir, { recursive: true })
+        }
+
+        // Write the file to disk.
+        pendingWrites++
+        zipFile.openReadStream(entry, noError(reject, (readStream) => {
+          const file = createWriteStream(join(target, entry.fileName))
+          readStream.pipe(file)
+
+          // Handle errors
+          file.on('error', (err) => {
+            pendingWrites--
+            zipFile.close()
+            reject(err)
+          })
+
+          // Wait until the file is finished writing, then read the next entry.
+          file.on('finish', () => {
+            file.close(() => {
+              pendingWrites--
+              if (pendingWrites === 0) {
+                resolve()
+              }
+
+              zipFile.readEntry()
+            })
+          })
+        }))
+      })
+
+      zipFile.on('error', onError(reject, zipFile.close))
+      zipFile.on('end', resolveWhenNoError(reject, resolve))
+    }))
+  })
+}