Move to TypeScript

.eslintrc

@@ -25,7 +25,10 @@
         "devDependencies": ["test/**/*.js"]
       }
     ],
-    "import/extensions": ["error", "ignorePackages"]
+    // Disabled for now, because we cannot use the .ts extension.
+    // TODO: Reevaluate this once all source files have been moved to TS
+    "import/extensions": ["off"],
+    "import/no-unresolved": ["off"]
   },
   "overrides": [
     {

lib/browser/index.js

@@ -1,15 +1,15 @@
-import BaseUpload from '../upload.js'
+import BaseUpload, { defaultOptions as baseDefaultOptions, terminate } from '../upload'
 import NoopUrlStorage from '../noopUrlStorage.js'
-import { enableDebugLog } from '../logger.js'
-import DetailedError from '../error.js'
+import { enableDebugLog } from '../logger'
+import DetailedError from '../error'
 
 import { canStoreURLs, WebStorageUrlStorage } from './urlStorage.js'
 import DefaultHttpStack from './httpStack.js'
 import FileReader from './fileReader.js'
 import fingerprint from './fileSignature.js'
 
 const defaultOptions = {
-  ...BaseUpload.defaultOptions,
+  ...baseDefaultOptions,
   httpStack: new DefaultHttpStack(),
   fileReader: new FileReader(),
   urlStorage: canStoreURLs ? new WebStorageUrlStorage() : new NoopUrlStorage(),
@@ -24,7 +24,7 @@ class Upload extends BaseUpload {
 
   static terminate(url, options = {}) {
     options = { ...defaultOptions, ...options }
-    return BaseUpload.terminate(url, options)
+    return terminate(url, options)
   }
 }
 

lib/error.js → lib/error.ts

@@ -1,5 +1,11 @@
+import { HttpRequest, HttpResponse } from './upload'
+
 class DetailedError extends Error {
-  constructor(message, causingErr = null, req = null, res = null) {
+  originalRequest?: HttpRequest<unknown>
+  originalResponse?: HttpResponse
+  causingError?: Error
+
+  constructor(message: string, causingErr?: Error, req?: HttpRequest<unknown>, res?: HttpResponse) {
     super(message)
 
     this.originalRequest = req

lib/index.d.ts

@@ -1,4 +1,5 @@
 // Type definitions for tus-js-client
+// TODO: Remove this file
 
 export const isSupported: boolean
 export const canStoreURLs: boolean

lib/index.test-d.ts

@@ -1,6 +1,7 @@
 // This is a test file for ensuring that the type definitions in index.d.ts are
 // working correctly. For more details see:
 // https://github.com/SamVerschueren/tsd
+// TODO: Remove this file
 
 import * as tus from '../'
 import { expectType } from 'tsd'

lib/logger.js → lib/logger.ts

@@ -2,11 +2,11 @@
 
 let isEnabled = false
 
-export function enableDebugLog() {
+export function enableDebugLog(): void {
   isEnabled = true
 }
 
-export function log(msg) {
+export function log(msg: string): void {
   if (!isEnabled) return
   console.log(msg)
 }

lib/node/fileReader.js → lib/node/fileReader.ts

@@ -1,12 +1,16 @@
 import { ReadStream } from 'fs'
 import isStream from 'is-stream'
 
-import BufferSource from './sources/BufferSource.js'
-import getFileSource from './sources/FileSource.js'
-import StreamSource from './sources/StreamSource.js'
+import { FileReader as IFileReader } from '../upload'
+import BufferSource from './sources/BufferSource'
+import getFileSource from './sources/FileSource'
+import StreamSource from './sources/StreamSource'
+import { FileSliceTypes, FileTypes } from './index'
 
-export default class FileReader {
-  openFile(input, chunkSize) {
+// TODO: Consider renaming this NodeFileReader
+export default class FileReader implements IFileReader<FileTypes, FileSliceTypes> {
+  // TODO: Use async here and less Promise.resolve
+  openFile(input: FileTypes, chunkSize: number) {
     if (Buffer.isBuffer(input)) {
       return Promise.resolve(new BufferSource(input))
     }

lib/node/fileSignature.js → lib/node/fileSignature.ts

@@ -1,14 +1,19 @@
 import * as fs from 'fs'
 import * as path from 'path'
 import { createHash } from 'crypto'
+import { UploadOptions } from '../upload'
+import { FileTypes, FileSliceTypes } from './index'
 
 /**
  * Generate a fingerprint for a file which will be used the store the endpoint
  *
  * @param {File} file
  * @param {Object} options
  */
-export default function fingerprint(file, options) {
+export default function fingerprint(
+  file: FileTypes,
+  options: UploadOptions<FileTypes, FileSliceTypes>,
+): Promise<string | null> {
   if (Buffer.isBuffer(file)) {
     // create MD5 hash for buffer type
     const blockSize = 64 * 1024 // 64kb
@@ -20,7 +25,9 @@ export default function fingerprint(file, options) {
 
   if (file instanceof fs.ReadStream && file.path != null) {
     return new Promise((resolve, reject) => {
-      const name = path.resolve(file.path)
+      const name = path.resolve(
+        Buffer.isBuffer(file.path) ? file.path.toString('utf-8') : file.path,
+      )
       fs.stat(file.path, (err, info) => {
         if (err) {
           reject(err)

lib/node/httpStack.js → lib/node/httpStack.ts

@@ -6,13 +6,17 @@ import * as https from 'https'
 import { parse } from 'url'
 import { Readable, Transform } from 'stream'
 import throttle from 'lodash.throttle'
+import { HttpProgressHandler, HttpRequest, HttpResponse, HttpStack } from '../upload'
+import { FileSliceTypes } from './index'
 
-export default class NodeHttpStack {
-  constructor(requestOptions = {}) {
+export default class NodeHttpStack implements HttpStack<FileSliceTypes> {
+  private _requestOptions: http.RequestOptions
+
+  constructor(requestOptions: http.RequestOptions = {}) {
     this._requestOptions = requestOptions
   }
 
-  createRequest(method, url) {
+  createRequest(method: string, url: string) {
     return new Request(method, url, this._requestOptions)
   }
 
@@ -21,14 +25,18 @@ export default class NodeHttpStack {
   }
 }
 
-class Request {
-  constructor(method, url, options) {
+class Request implements HttpRequest<FileSliceTypes> {
+  _method: string
+  _url: string
+  _headers: Record<string, string> = {}
+  _request: http.ClientRequest | null = null
+  _progressHandler: HttpProgressHandler = () => {}
+  _requestOptions: http.RequestOptions
+
+  constructor(method: string, url: string, options: http.RequestOptions) {
     this._method = method
     this._url = url
-    this._headers = {}
-    this._request = null
-    this._progressHandler = () => {}
-    this._requestOptions = options || {}
+    this._requestOptions = options
   }
 
   getMethod() {
@@ -39,19 +47,19 @@ class Request {
     return this._url
   }
 
-  setHeader(header, value) {
+  setHeader(header: string, value: string) {
     this._headers[header] = value
   }
 
-  getHeader(header) {
+  getHeader(header: string) {
     return this._headers[header]
   }
 
-  setProgressHandler(progressHandler) {
+  setProgressHandler(progressHandler: HttpProgressHandler) {
     this._progressHandler = progressHandler
   }
 
-  send(body = null) {
+  send(body?: FileSliceTypes): Promise<HttpResponse> {
     return new Promise((resolve, reject) => {
       const options = {
         ...parse(this._url),
@@ -64,16 +72,18 @@ class Request {
         },
       }
 
+      //@ts-expect-error
       if (body && body.size) {
+        //@ts-expect-error
         options.headers['Content-Length'] = body.size
       }
 
       const httpModule = options.protocol === 'https:' ? https : http
       this._request = httpModule.request(options)
       const req = this._request
       req.on('response', (res) => {
-        const resChunks = []
-        res.on('data', (data) => {
+        const resChunks: Buffer[] = []
+        res.on('data', (data: Buffer) => {
           resChunks.push(data)
         })
 
@@ -114,18 +124,28 @@ class Request {
   }
 }
 
-class Response {
-  constructor(res, body) {
+class Response implements HttpResponse {
+  _response: http.IncomingMessage
+  _body: string
+
+  constructor(res: http.IncomingMessage, body: string) {
     this._response = res
     this._body = body
   }
 
   getStatus() {
+    if (this._response.statusCode == undefined) {
+      throw new Error('no status code available yet')
+    }
     return this._response.statusCode
   }
 
-  getHeader(header) {
-    return this._response.headers[header.toLowerCase()]
+  getHeader(header: string) {
+    const values = this._response.headers[header.toLowerCase()]
+    if (Array.isArray(values)) {
+      return values.join(', ')
+    }
+    return values
   }
 
   getBody() {
@@ -141,7 +161,10 @@ class Response {
 // track of the number of bytes which have been piped through it and will
 // invoke the `onprogress` function whenever new number are available.
 class ProgressEmitter extends Transform {
-  constructor(onprogress) {
+  _onprogress: HttpProgressHandler
+  _position = 0
+
+  constructor(onprogress: HttpProgressHandler) {
     super()
 
     // The _onprogress property will be invoked, whenever a chunk is piped
@@ -153,10 +176,9 @@ class ProgressEmitter extends Transform {
       leading: true,
       trailing: false,
     })
-    this._position = 0
   }
 
-  _transform(chunk, encoding, callback) {
+  _transform(chunk: Buffer, encoding: string, callback: (err: Error | null, data: Buffer) => void) {
     this._position += chunk.length
     this._onprogress(this._position)
     callback(null, chunk)