https://breadmastergames.github.io/inputfile.js

1(function () {
2    window.BlazorInputFile = {
3        init: function init(elem, componentInstance) {
4            var nextFileId = 0;
5
6            elem.addEventListener('change', function handleInputFileChange(event) {
7                // Reduce to purely serializable data, plus build an index by ID
8                elem._blazorFilesById = {};
9                var fileList = Array.prototype.map.call(elem.files, function (file) {
10                    var result = {
11                        id: ++nextFileId,
12                        lastModified: new Date(file.lastModified).toISOString(),
13                        name: file.name,
14                        size: file.size,
15                        type: file.type
16                    };
17                    elem._blazorFilesById[result.id] = result;
18
19                    // Attach the blob data itself as a non-enumerable property so it doesn't appear in the JSON
20                    Object.defineProperty(result, 'blob', { value: file });
21
22                    return result;
23                });
24
25                componentInstance.invokeMethodAsync('NotifyChange', fileList).then(null, function (err) {
26                    throw new Error(err);
27                });
28            });
29        },
30
31        readFileData: function readFileData(elem, fileId, startOffset, count) {
32            var readPromise = getArrayBufferFromFileAsync(elem, fileId);
33
34            return readPromise.then(function (arrayBuffer) {
35                var uint8Array = new Uint8Array(arrayBuffer, startOffset, count);
36                var base64 = uint8ToBase64(uint8Array);
37                return base64;
38            });
39        },
40
41        ensureArrayBufferReadyForSharedMemoryInterop: function ensureArrayBufferReadyForSharedMemoryInterop(elem, fileId) {
42            return getArrayBufferFromFileAsync(elem, fileId).then(function (arrayBuffer) {
43                getFileById(elem, fileId).arrayBuffer = arrayBuffer;
44            });
45        },
46
47        readFileDataSharedMemory: function readFileDataSharedMemory(readRequest) {
48            // This uses various unsupported internal APIs. Beware that if you also use them,
49            // your code could become broken by any update.
50            var inputFileElementReferenceId = Blazor.platform.readStringField(readRequest, 0);
51            var inputFileElement = document.querySelector('[_bl_' + inputFileElementReferenceId + ']');
52            var fileId = Blazor.platform.readInt32Field(readRequest, 4);
53            var sourceOffset = Blazor.platform.readUint64Field(readRequest, 8);
54            var destination = Blazor.platform.readInt32Field(readRequest, 16);
55            var destinationOffset = Blazor.platform.readInt32Field(readRequest, 20);
56            var maxBytes = Blazor.platform.readInt32Field(readRequest, 24);
57
58            var sourceArrayBuffer = getFileById(inputFileElement, fileId).arrayBuffer;
59            var bytesToRead = Math.min(maxBytes, sourceArrayBuffer.byteLength - sourceOffset);
60            var sourceUint8Array = new Uint8Array(sourceArrayBuffer, sourceOffset, bytesToRead);
61
62            var destinationUint8Array = Blazor.platform.toUint8Array(destination);
63            destinationUint8Array.set(sourceUint8Array, destinationOffset);
64
65            return bytesToRead;
66        }
67    };
68
69    function getFileById(elem, fileId) {
70        var file = elem._blazorFilesById[fileId];
71        if (!file) {
72            throw new Error('There is no file with ID ' + fileId + '. The file list may have changed');
73        }
74
75        return file;
76    }
77
78    function getArrayBufferFromFileAsync(elem, fileId) {
79        var file = getFileById(elem, fileId);
80
81        // On the first read, convert the FileReader into a Promise<ArrayBuffer>
82        if (!file.readPromise) {
83            file.readPromise = new Promise(function (resolve, reject) {
84                var reader = new FileReader();
85                reader.onload = function () { resolve(reader.result); };
86                reader.onerror = function (err) { reject(err); };
87                reader.readAsArrayBuffer(file.blob);
88            });
89        }
90
91        return file.readPromise;
92    }
93
94    var uint8ToBase64 = (function () {
95        // Code from https://github.com/beatgammit/base64-js/
96        // License: MIT
97        var lookup = [];
98
99        var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789

99+/';
100        for (var i = 0, len = code.length; i < len; ++i) {
101            lookup[i] = code[i];
102        }
103
104        function tripletToBase64(num) {
105            return lookup[num >> 18 & 0x3F] +
106                lookup[num >> 12 & 0x3F] +
107                lookup[num >> 6 & 0x3F] +
108                lookup[num & 0x3F];
109        }
110
111        function encodeChunk(uint8, start, end) {
112            var tmp;
113            var output = [];
114            for (var i = start; i < end; i += 3) {
115                tmp =
116                    ((uint8[i] << 16) & 0xFF0000) +
117                    ((uint8[i + 1] << 8) & 0xFF00) +
118                    (uint8[i + 2] & 0xFF);
119                output.push(tripletToBase64(tmp));
120            }
121            return output.join('');
122        }
123
124        return function fromByteArray(uint8) {
125            var tmp;
126            var len = uint8.length;
127            var extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
128            var parts = [];
129            var maxChunkLength = 16383; // must be multiple of 3
130
131            // go through the array every three bytes, we'll deal with trailing stuff later
132            for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
133                parts.push(encodeChunk(
134                    uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)
135                ));
136            }
137
138            // pad the end with zeros, but make sure to not forget the extra bytes
139            if (extraBytes === 1) {
140                tmp = uint8[len - 1];
141                parts.push(
142                    lookup[tmp >> 2] +
143                    lookup[(tmp << 4) & 0x3F] +
144                    '=='
145                );
146            } else if (extraBytes === 2) {
147                tmp = (uint8[len - 2] << 8) + uint8[len - 1];
148                parts.push(
149                    lookup[tmp >> 10] +
150                    lookup[(tmp >> 4) & 0x3F] +
151                    lookup[(tmp << 2) & 0x3F] +
152                    '='
153                );
154            }
155
156            return parts.join('');
157        };
158    })();
159})();