@entrinsik/vite-plugin-informer 2.7.0 → 2.11.0

package/src/streams-client.js

@@ -0,0 +1,200 @@
+/**
+ * Dev copy of the injected app streams client (I5-12979):
+ * `__INFORMER__.upload(file, opts)` and `__INFORMER__.downloadUrl(id, filename)`.
+ *
+ * VERBATIM copy of modules/app/routes/lib/html-utils.js#generateStreamsHelper
+ * in its origin-mode form (base "", plain window.fetch / XHR transport — the
+ * dev server IS the app's origin, so the same-origin /_uploads and /_downloads
+ * middleware serves it). The plugin cannot import the server module (different
+ * runtime, no dependency), so the copy is pinned byte-for-byte by
+ * test/streams-parity.test.js: change the protocol or retry policy there, and
+ * that test says exactly what to paste here. The dev page must upload the way
+ * a deployed one does.
+ *
+ * @returns {string} JavaScript expression evaluating to { upload, downloadUrl }
+ */
+export function streamsClientSource() {
+    return `(function (base, transport) {
+        var DEFAULTS = { chunkSize: 4 * 1024 * 1024, concurrency: 3, retries: 5 };
+
+        function delay (ms) { return new Promise(function (resolve) { setTimeout(resolve, ms); }); }
+        function backoff (attempt) { return Math.min(8000, 500 * Math.pow(2, attempt)) * (0.5 + Math.random()); }
+        function retryable (status) { return status === 0 || status === 408 || status === 429 || status >= 500; }
+        function httpError (status, data, fallback) {
+            var err = new Error((data && (data.message || data.error)) || fallback || ('HTTP ' + status));
+            err.status = status;
+            err.data = data && data.data;
+            return err;
+        }
+
+        function json (method, url, body) {
+            var opts = { method: method, credentials: 'same-origin', headers: {} };
+            if (body !== undefined) { opts.headers['Content-Type'] = 'application/json'; opts.body = JSON.stringify(body); }
+            return transport.fetch(url, opts).then(function (res) {
+                return res.text().then(function (text) {
+                    var data = null;
+                    try { data = text ? JSON.parse(text) : null; } catch (e) { data = text; }
+                    if (!res.ok) throw httpError(res.status, data);
+                    return data;
+                });
+            });
+        }
+
+        // XHR rather than fetch for the chunk body: byte-level upload progress
+        // events and a synchronous abort.
+        function putChunk (url, blob, signal, onProgress) {
+            return new Promise(function (resolve, reject) {
+                var xhr = new XMLHttpRequest();
+                transport.open(xhr, 'PUT', url);
+                xhr.setRequestHeader('Content-Type', 'application/octet-stream');
+                xhr.withCredentials = true;
+                // Without this, ontimeout can never fire and a half-open socket
+                // (VPN drop, laptop sleep, an idle reap with no RST) leaves the
+                // promise pending forever. Allows ~8 KB/s before giving up, so a
+                // genuinely slow link retries rather than stalls.
+                xhr.timeout = Math.max(60000, Math.ceil(blob.size / 8));
+                if (xhr.upload && onProgress) {
+                    xhr.upload.onprogress = function (e) { if (e.lengthComputable) onProgress(e.loaded); };
+                }
+                xhr.onload = function () {
+                    if (xhr.status >= 200 && xhr.status < 300) return resolve();
+                    var data = null;
+                    try { data = xhr.responseText ? JSON.parse(xhr.responseText) : null; } catch (e) { data = null; }
+                    reject(httpError(xhr.status, data, 'Chunk upload failed: HTTP ' + xhr.status));
+                };
+                xhr.onerror = function () { reject(httpError(0, null, 'Network error during chunk upload')); };
+                xhr.ontimeout = function () { reject(httpError(408, null, 'Chunk upload timed out')); };
+                xhr.onabort = function () { var err = new Error('Upload aborted'); err.code = 'aborted'; reject(err); };
+                if (signal) {
+                    if (signal.aborted) { xhr.abort(); return; }
+                    signal.addEventListener('abort', function () { xhr.abort(); });
+                }
+                xhr.send(blob);
+            });
+        }
+
+        // Name + length + mtime. Enough to stop a different file being spliced
+        // into a resumed upload; not a checksum, which would mean reading the
+        // whole file in the page before the first byte goes out.
+        function fingerprintOf (file, opts) {
+            return [opts.filename || file.name || '', file.size, file.lastModified || 0].join(':');
+        }
+
+        function upload (file, opts) {
+            opts = opts || {};
+            if (!file || typeof file.slice !== 'function' || typeof file.size !== 'number') {
+                return Promise.reject(new Error('upload(file): a File or Blob is required'));
+            }
+            var controller = new AbortController();
+            if (opts.signal) {
+                // An already-aborted signal never fires 'abort' — mirror its state now.
+                if (opts.signal.aborted) controller.abort();
+                else opts.signal.addEventListener('abort', function () { controller.abort(); });
+            }
+            var signal = controller.signal;
+            var retries = opts.retries != null ? opts.retries : DEFAULTS.retries;
+            var concurrency = Math.max(1, opts.concurrency || DEFAULTS.concurrency);
+            var task = { id: opts.resume || null, abort: function () { controller.abort(); } };
+            var loaded = {};
+
+            function progress () {
+                if (typeof opts.onProgress !== 'function') return;
+                var sum = 0;
+                for (var k in loaded) sum += loaded[k];
+                opts.onProgress({ loaded: sum, total: file.size, percent: file.size ? Math.min(100, Math.floor(sum * 100 / file.size)) : 100 });
+            }
+            function abortError () { var err = new Error('Upload aborted'); err.code = 'aborted'; return err; }
+
+            function sendChunk (meta, n, attempt) {
+                if (signal.aborted) return Promise.reject(abortError());
+                var start = (n - 1) * meta.chunkSize;
+                var blob = file.slice(start, Math.min(file.size, start + meta.chunkSize));
+                return putChunk(base + '/_uploads/' + meta.id + '/' + n, blob, signal, function (sent) { loaded[n] = sent; progress(); })
+                    .then(function () { loaded[n] = blob.size; progress(); })
+                    .catch(function (err) {
+                        if (err.code === 'aborted' || signal.aborted) throw err;
+                        if (err.status === 404) { var gone = new Error('Upload expired before it completed'); gone.code = 'upload_expired'; gone.status = 404; throw gone; }
+                        if (!retryable(err.status) || attempt >= retries) throw err;
+                        return delay(backoff(attempt)).then(function () { return sendChunk(meta, n, attempt + 1); });
+                    });
+            }
+
+            function sendAll (meta, chunks) {
+                var next = 0;
+                function worker () {
+                    if (next >= chunks.length || signal.aborted) return Promise.resolve();
+                    var n = chunks[next++];
+                    return sendChunk(meta, n, 0).then(worker);
+                }
+                var workers = [];
+                for (var i = 0; i < Math.min(concurrency, chunks.length); i++) workers.push(worker());
+                return Promise.all(workers);
+            }
+
+            var plan = signal.aborted ? Promise.reject(abortError()) : opts.resume
+                ? json('GET', base + '/_uploads/' + encodeURIComponent(opts.resume)).then(function (meta) {
+                    // Size alone is not identity: two same-length files would be
+                    // spliced into one upload that completes without complaint.
+                    var fp = fingerprintOf(file, opts);
+                    if (meta.size !== file.size || (meta.fingerprint && meta.fingerprint !== fp)) {
+                        throw new Error('upload({ resume }): the file does not match the upload being resumed');
+                    }
+                    (meta.received || []).forEach(function (n) {
+                        loaded[n] = n < meta.chunks ? meta.chunkSize : meta.size - meta.chunkSize * (meta.chunks - 1);
+                    });
+                    return { meta: meta, chunks: meta.complete ? [] : (meta.missing || []) };
+                })
+                : json('POST', base + '/_uploads', {
+                    filename: opts.filename || file.name || 'upload',
+                    contentType: opts.contentType || file.type || undefined,
+                    size: file.size,
+                    fingerprint: fingerprintOf(file, opts),
+                    chunkSize: opts.chunkSize || DEFAULTS.chunkSize
+                }).then(function (meta) {
+                    var chunks = [];
+                    for (var n = 1; n <= meta.chunks; n++) chunks.push(n);
+                    return { meta: meta, chunks: chunks };
+                });
+
+            var promise = plan
+                .then(function (p) {
+                    task.id = p.meta.id;
+                    progress();
+                    return sendAll(p.meta, p.chunks).then(function () {
+                        if (signal.aborted) throw abortError();
+                        return json('POST', base + '/_uploads/' + p.meta.id + '/_complete');
+                    });
+                })
+                .then(function (handle) { progress(); return handle; })
+                .catch(function (err) {
+                    var aborted = err.code === 'aborted' || signal.aborted;
+                    // Promise.all rejects on the first failure but leaves the other
+                    // workers retrying with backoff; stop them before returning.
+                    controller.abort();
+                    if (task.id) {
+                        // Discard only on an explicit abort — the caller is done
+                        // with it. Any other failure keeps the staged chunks so
+                        // upload({ resume: err.uploadId }) can finish the job; the
+                        // TTL reclaims them if it never does.
+                        if (aborted) transport.fetch(base + '/_uploads/' + task.id, { method: 'DELETE', credentials: 'same-origin' }).catch(function () {});
+                        else err.uploadId = task.id;
+                    }
+                    throw err;
+                });
+
+            task.then = function (onFulfilled, onRejected) { return promise.then(onFulfilled, onRejected); };
+            task['catch'] = function (onRejected) { return promise['catch'](onRejected); };
+            task['finally'] = function (onFinally) { return promise['finally'](onFinally); };
+            return task;
+        }
+
+        function downloadUrl (id, filename) {
+            return base + '/_downloads/' + encodeURIComponent(id) + (filename ? '/' + encodeURIComponent(filename) : '');
+        }
+
+        return { upload: upload, downloadUrl: downloadUrl };
+    })("", {
+            fetch: function (url, opts) { return window.fetch(url, opts); },
+            open: function (xhr, method, url) { xhr.open(method, url); }
+        })`;
+}