@netlify/plugin-nextjs 4.40.0 → 4.40.2

package/src/templates/vendor/deno.land/std@0.175.0/node/internal/streams/destroy.mjs

@@ -0,0 +1,320 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// Copyright Joyent and Node contributors. All rights reserved. MIT license.
+// deno-lint-ignore-file
+
+import { aggregateTwoErrors, ERR_MULTIPLE_CALLBACK } from "../errors.ts";
+import * as process from "../../_process/process.ts";
+
+const kDestroy = Symbol("kDestroy");
+const kConstruct = Symbol("kConstruct");
+
+function checkError(err, w, r) {
+  if (err) {
+    // Avoid V8 leak, https://github.com/nodejs/node/pull/34103#issuecomment-652002364
+    err.stack; // eslint-disable-line no-unused-expressions
+
+    if (w && !w.errored) {
+      w.errored = err;
+    }
+    if (r && !r.errored) {
+      r.errored = err;
+    }
+  }
+}
+
+// Backwards compat. cb() is undocumented and unused in core but
+// unfortunately might be used by modules.
+function destroy(err, cb) {
+  const r = this._readableState;
+  const w = this._writableState;
+  // With duplex streams we use the writable side for state.
+  const s = w || r;
+
+  if ((w && w.destroyed) || (r && r.destroyed)) {
+    if (typeof cb === "function") {
+      cb();
+    }
+
+    return this;
+  }
+
+  // We set destroyed to true before firing error callbacks in order
+  // to make it re-entrance safe in case destroy() is called within callbacks
+  checkError(err, w, r);
+
+  if (w) {
+    w.destroyed = true;
+  }
+  if (r) {
+    r.destroyed = true;
+  }
+
+  // If still constructing then defer calling _destroy.
+  if (!s.constructed) {
+    this.once(kDestroy, function (er) {
+      _destroy(this, aggregateTwoErrors(er, err), cb);
+    });
+  } else {
+    _destroy(this, err, cb);
+  }
+
+  return this;
+}
+
+function _destroy(self, err, cb) {
+  let called = false;
+
+  function onDestroy(err) {
+    if (called) {
+      return;
+    }
+    called = true;
+
+    const r = self._readableState;
+    const w = self._writableState;
+
+    checkError(err, w, r);
+
+    if (w) {
+      w.closed = true;
+    }
+    if (r) {
+      r.closed = true;
+    }
+
+    if (typeof cb === "function") {
+      cb(err);
+    }
+
+    if (err) {
+      process.nextTick(emitErrorCloseNT, self, err);
+    } else {
+      process.nextTick(emitCloseNT, self);
+    }
+  }
+  try {
+    const result = self._destroy(err || null, onDestroy);
+    if (result != null) {
+      const then = result.then;
+      if (typeof then === "function") {
+        then.call(
+          result,
+          function () {
+            process.nextTick(onDestroy, null);
+          },
+          function (err) {
+            process.nextTick(onDestroy, err);
+          },
+        );
+      }
+    }
+  } catch (err) {
+    onDestroy(err);
+  }
+}
+
+function emitErrorCloseNT(self, err) {
+  emitErrorNT(self, err);
+  emitCloseNT(self);
+}
+
+function emitCloseNT(self) {
+  const r = self._readableState;
+  const w = self._writableState;
+
+  if (w) {
+    w.closeEmitted = true;
+  }
+  if (r) {
+    r.closeEmitted = true;
+  }
+
+  if ((w && w.emitClose) || (r && r.emitClose)) {
+    self.emit("close");
+  }
+}
+
+function emitErrorNT(self, err) {
+  const r = self._readableState;
+  const w = self._writableState;
+
+  if ((w && w.errorEmitted) || (r && r.errorEmitted)) {
+    return;
+  }
+
+  if (w) {
+    w.errorEmitted = true;
+  }
+  if (r) {
+    r.errorEmitted = true;
+  }
+
+  self.emit("error", err);
+}
+
+function undestroy() {
+  const r = this._readableState;
+  const w = this._writableState;
+
+  if (r) {
+    r.constructed = true;
+    r.closed = false;
+    r.closeEmitted = false;
+    r.destroyed = false;
+    r.errored = null;
+    r.errorEmitted = false;
+    r.reading = false;
+    r.ended = false;
+    r.endEmitted = false;
+  }
+
+  if (w) {
+    w.constructed = true;
+    w.destroyed = false;
+    w.closed = false;
+    w.closeEmitted = false;
+    w.errored = null;
+    w.errorEmitted = false;
+    w.ended = false;
+    w.ending = false;
+    w.finalCalled = false;
+    w.prefinished = false;
+    w.finished = false;
+  }
+}
+
+function errorOrDestroy(stream, err, sync) {
+  // We have tests that rely on errors being emitted
+  // in the same tick, so changing this is semver major.
+  // For now when you opt-in to autoDestroy we allow
+  // the error to be emitted nextTick. In a future
+  // semver major update we should change the default to this.
+
+  const r = stream._readableState;
+  const w = stream._writableState;
+
+  if ((w && w.destroyed) || (r && r.destroyed)) {
+    return this;
+  }
+
+  if ((r && r.autoDestroy) || (w && w.autoDestroy)) {
+    stream.destroy(err);
+  } else if (err) {
+    // Avoid V8 leak, https://github.com/nodejs/node/pull/34103#issuecomment-652002364
+    err.stack; // eslint-disable-line no-unused-expressions
+
+    if (w && !w.errored) {
+      w.errored = err;
+    }
+    if (r && !r.errored) {
+      r.errored = err;
+    }
+    if (sync) {
+      process.nextTick(emitErrorNT, stream, err);
+    } else {
+      emitErrorNT(stream, err);
+    }
+  }
+}
+
+function construct(stream, cb) {
+  if (typeof stream._construct !== "function") {
+    return;
+  }
+
+  const r = stream._readableState;
+  const w = stream._writableState;
+
+  if (r) {
+    r.constructed = false;
+  }
+  if (w) {
+    w.constructed = false;
+  }
+
+  stream.once(kConstruct, cb);
+
+  if (stream.listenerCount(kConstruct) > 1) {
+    // Duplex
+    return;
+  }
+
+  process.nextTick(constructNT, stream);
+}
+
+function constructNT(stream) {
+  let called = false;
+
+  function onConstruct(err) {
+    if (called) {
+      errorOrDestroy(stream, err ?? new ERR_MULTIPLE_CALLBACK());
+      return;
+    }
+    called = true;
+
+    const r = stream._readableState;
+    const w = stream._writableState;
+    const s = w || r;
+
+    if (r) {
+      r.constructed = true;
+    }
+    if (w) {
+      w.constructed = true;
+    }
+
+    if (s.destroyed) {
+      stream.emit(kDestroy, err);
+    } else if (err) {
+      errorOrDestroy(stream, err, true);
+    } else {
+      process.nextTick(emitConstructNT, stream);
+    }
+  }
+
+  try {
+    const result = stream._construct(onConstruct);
+    if (result != null) {
+      const then = result.then;
+      if (typeof then === "function") {
+        then.call(
+          result,
+          function () {
+            process.nextTick(onConstruct, null);
+          },
+          function (err) {
+            process.nextTick(onConstruct, err);
+          },
+        );
+      }
+    }
+  } catch (err) {
+    onConstruct(err);
+  }
+}
+
+function emitConstructNT(stream) {
+  stream.emit(kConstruct);
+}
+
+function isRequest(stream) {
+  return stream && stream.setHeader && typeof stream.abort === "function";
+}
+
+// Normalize destroy for legacy.
+function destroyer(stream, err) {
+  if (!stream) return;
+  if (isRequest(stream)) return stream.abort();
+  if (isRequest(stream.req)) return stream.req.abort();
+  if (typeof stream.destroy === "function") return stream.destroy(err);
+  if (typeof stream.close === "function") return stream.close();
+}
+
+export default {
+  construct,
+  destroyer,
+  destroy,
+  undestroy,
+  errorOrDestroy,
+};
+export { construct, destroy, destroyer, errorOrDestroy, undestroy };

package/src/templates/vendor/deno.land/std@0.175.0/node/internal/streams/end-of-stream.mjs

@@ -0,0 +1,229 @@
+// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
+// Copyright Joyent and Node contributors. All rights reserved. MIT license.
+// deno-lint-ignore-file
+
+import { AbortError, ERR_STREAM_PREMATURE_CLOSE } from "../errors.ts";
+import { once } from "../util.mjs";
+import {
+  validateAbortSignal,
+  validateFunction,
+  validateObject,
+} from "../validators.mjs";
+import * as process from "../../_process/process.ts";
+
+function isRequest(stream) {
+  return stream.setHeader && typeof stream.abort === "function";
+}
+
+function isServerResponse(stream) {
+  return (
+    typeof stream._sent100 === "boolean" &&
+    typeof stream._removedConnection === "boolean" &&
+    typeof stream._removedContLen === "boolean" &&
+    typeof stream._removedTE === "boolean" &&
+    typeof stream._closed === "boolean"
+  );
+}
+
+function isReadable(stream) {
+  return typeof stream.readable === "boolean" ||
+    typeof stream.readableEnded === "boolean" ||
+    !!stream._readableState;
+}
+
+function isWritable(stream) {
+  return typeof stream.writable === "boolean" ||
+    typeof stream.writableEnded === "boolean" ||
+    !!stream._writableState;
+}
+
+function isWritableFinished(stream) {
+  if (stream.writableFinished) return true;
+  const wState = stream._writableState;
+  if (!wState || wState.errored) return false;
+  return wState.finished || (wState.ended && wState.length === 0);
+}
+
+const nop = () => {};
+
+function isReadableEnded(stream) {
+  if (stream.readableEnded) return true;
+  const rState = stream._readableState;
+  if (!rState || rState.errored) return false;
+  return rState.endEmitted || (rState.ended && rState.length === 0);
+}
+
+function eos(stream, options, callback) {
+  if (arguments.length === 2) {
+    callback = options;
+    options = {};
+  } else if (options == null) {
+    options = {};
+  } else {
+    validateObject(options, "options");
+  }
+  validateFunction(callback, "callback");
+  validateAbortSignal(options.signal, "options.signal");
+
+  callback = once(callback);
+
+  const readable = options.readable ||
+    (options.readable !== false && isReadable(stream));
+  const writable = options.writable ||
+    (options.writable !== false && isWritable(stream));
+
+  const wState = stream._writableState;
+  const rState = stream._readableState;
+  const state = wState || rState;
+
+  const onlegacyfinish = () => {
+    if (!stream.writable) onfinish();
+  };
+
+  // TODO (ronag): Improve soft detection to include core modules and
+  // common ecosystem modules that do properly emit 'close' but fail
+  // this generic check.
+  let willEmitClose = isServerResponse(stream) || (
+    state &&
+    state.autoDestroy &&
+    state.emitClose &&
+    state.closed === false &&
+    isReadable(stream) === readable &&
+    isWritable(stream) === writable
+  );
+
+  let writableFinished = stream.writableFinished ||
+    (wState && wState.finished);
+  const onfinish = () => {
+    writableFinished = true;
+    // Stream should not be destroyed here. If it is that
+    // means that user space is doing something differently and
+    // we cannot trust willEmitClose.
+    if (stream.destroyed) willEmitClose = false;
+
+    if (willEmitClose && (!stream.readable || readable)) return;
+    if (!readable || readableEnded) callback.call(stream);
+  };
+
+  let readableEnded = stream.readableEnded ||
+    (rState && rState.endEmitted);
+  const onend = () => {
+    readableEnded = true;
+    // Stream should not be destroyed here. If it is that
+    // means that user space is doing something differently and
+    // we cannot trust willEmitClose.
+    if (stream.destroyed) willEmitClose = false;
+
+    if (willEmitClose && (!stream.writable || writable)) return;
+    if (!writable || writableFinished) callback.call(stream);
+  };
+
+  const onerror = (err) => {
+    callback.call(stream, err);
+  };
+
+  const onclose = () => {
+    if (readable && !readableEnded) {
+      if (!isReadableEnded(stream)) {
+        return callback.call(stream, new ERR_STREAM_PREMATURE_CLOSE());
+      }
+    }
+    if (writable && !writableFinished) {
+      if (!isWritableFinished(stream)) {
+        return callback.call(stream, new ERR_STREAM_PREMATURE_CLOSE());
+      }
+    }
+    callback.call(stream);
+  };
+
+  const onrequest = () => {
+    stream.req.on("finish", onfinish);
+  };
+
+  if (isRequest(stream)) {
+    stream.on("complete", onfinish);
+    if (!willEmitClose) {
+      stream.on("abort", onclose);
+    }
+    if (stream.req) onrequest();
+    else stream.on("request", onrequest);
+  } else if (writable && !wState) { // legacy streams
+    stream.on("end", onlegacyfinish);
+    stream.on("close", onlegacyfinish);
+  }
+
+  // Not all streams will emit 'close' after 'aborted'.
+  if (!willEmitClose && typeof stream.aborted === "boolean") {
+    stream.on("aborted", onclose);
+  }
+
+  stream.on("end", onend);
+  stream.on("finish", onfinish);
+  if (options.error !== false) stream.on("error", onerror);
+  stream.on("close", onclose);
+
+  // _closed is for OutgoingMessage which is not a proper Writable.
+  const closed = (!wState && !rState && stream._closed === true) || (
+    (wState && wState.closed) ||
+    (rState && rState.closed) ||
+    (wState && wState.errorEmitted) ||
+    (rState && rState.errorEmitted) ||
+    (rState && stream.req && stream.aborted) ||
+    (
+      (!wState || !willEmitClose || typeof wState.closed !== "boolean") &&
+      (!rState || !willEmitClose || typeof rState.closed !== "boolean") &&
+      (!writable || (wState && wState.finished)) &&
+      (!readable || (rState && rState.endEmitted))
+    )
+  );
+
+  if (closed) {
+    // TODO(ronag): Re-throw error if errorEmitted?
+    // TODO(ronag): Throw premature close as if finished was called?
+    // before being closed? i.e. if closed but not errored, ended or finished.
+    // TODO(ronag): Throw some kind of error? Does it make sense
+    // to call finished() on a "finished" stream?
+    // TODO(ronag): willEmitClose?
+    process.nextTick(() => {
+      callback();
+    });
+  }
+
+  const cleanup = () => {
+    callback = nop;
+    stream.removeListener("aborted", onclose);
+    stream.removeListener("complete", onfinish);
+    stream.removeListener("abort", onclose);
+    stream.removeListener("request", onrequest);
+    if (stream.req) stream.req.removeListener("finish", onfinish);
+    stream.removeListener("end", onlegacyfinish);
+    stream.removeListener("close", onlegacyfinish);
+    stream.removeListener("finish", onfinish);
+    stream.removeListener("end", onend);
+    stream.removeListener("error", onerror);
+    stream.removeListener("close", onclose);
+  };
+
+  if (options.signal && !closed) {
+    const abort = () => {
+      // Keep it because cleanup removes it.
+      const endCallback = callback;
+      cleanup();
+      endCallback.call(stream, new AbortError());
+    };
+    if (options.signal.aborted) {
+      process.nextTick(abort);
+    } else {
+      const originalCallback = callback;
+      callback = once((...args) => {
+        options.signal.removeEventListener("abort", abort);
+        originalCallback.apply(stream, args);
+      });
+      options.signal.addEventListener("abort", abort);
+    }
+  }
+
+  return cleanup;
+}
+
+export default eos;