onnxruntime

1
// Copyright (c) Microsoft Corporation. All rights reserved.
2
// Licensed under the MIT License.
3

4
import { isNode } from './wasm-utils-env';
5

6
/**
7
 * Load a file into a Uint8Array.
8
 *
9
 * @param file - the file to load. Can be a URL/path, a Blob, an ArrayBuffer, or a Uint8Array.
10
 * @returns a Uint8Array containing the file data.
11
 */
12
export const loadFile = async (file: string | Blob | ArrayBufferLike | Uint8Array): Promise<Uint8Array> => {
13
  if (typeof file === 'string') {
14
    if (isNode) {
15
      // load file into ArrayBuffer in Node.js
16
      try {
17
        const { readFile } = require('node:fs/promises');
18
        return new Uint8Array(await readFile(file));
19
      } catch (e) {
20
        if (e.code === 'ERR_FS_FILE_TOO_LARGE') {
21
          // file is too large, use fs.createReadStream instead
22
          const { createReadStream } = require('node:fs');
23
          const stream = createReadStream(file);
24
          const chunks: Uint8Array[] = [];
25
          for await (const chunk of stream) {
26
            chunks.push(chunk);
27
          }
28
          return new Uint8Array(Buffer.concat(chunks));
29
        }
30
        throw e;
31
      }
32
    } else {
33
      // load file into ArrayBuffer in browsers
34
      const response = await fetch(file);
35
      if (!response.ok) {
36
        throw new Error(`failed to load external data file: ${file}`);
37
      }
38
      const contentLengthHeader = response.headers.get('Content-Length');
39
      const fileSize = contentLengthHeader ? parseInt(contentLengthHeader, 10) : 0;
40
      if (fileSize < 1073741824 /* 1GB */) {
41
        // when Content-Length header is not set, we cannot determine the file size. We assume it is small enough to
42
        // load into memory.
43
        return new Uint8Array(await response.arrayBuffer());
44
      } else {
45
        // file is too large, use stream instead
46
        if (!response.body) {
47
          throw new Error(`failed to load external data file: ${file}, no response body.`);
48
        }
49
        const reader = response.body.getReader();
50

51
        let buffer;
52
        try {
53
          // try to create ArrayBuffer directly
54
          buffer = new ArrayBuffer(fileSize);
55
        } catch (e) {
56
          if (e instanceof RangeError) {
57
            // use WebAssembly Memory to allocate larger ArrayBuffer
58
            const pages = Math.ceil(fileSize / 65536);
59
            buffer = new WebAssembly.Memory({ initial: pages, maximum: pages }).buffer;
60
          } else {
61
            throw e;
62
          }
63
        }
64

65
        let offset = 0;
66
        // eslint-disable-next-line no-constant-condition
67
        while (true) {
68
          const { done, value } = await reader.read();
69
          if (done) {
70
            break;
71
          }
72
          const chunkSize = value.byteLength;
73
          const chunk = new Uint8Array(buffer, offset, chunkSize);
74
          chunk.set(value);
75
          offset += chunkSize;
76
        }
77
        return new Uint8Array(buffer, 0, fileSize);
78
      }
79
    }
80
  } else if (file instanceof Blob) {
81
    return new Uint8Array(await file.arrayBuffer());
82
  } else if (file instanceof Uint8Array) {
83
    return file;
84
  } else {
85
    return new Uint8Array(file);
86
  }
87
};
88