replace fetch with http.request

Author: samizdatco

CHANGELOG.md

@@ -1,6 +1,12 @@
 # Changelog
 
-<!--## 🥚 ⟩ [Unreleased]-->
+## 🥚 ⟩ [Unreleased]
+
+### Misc. Improvements
+- When installing the module, any proxy server defined via `npm config set proxy` or an `HTTPS_PROXY` environment variable will be used to fetch the prebuilt binary
+- Replaced `fetch` altogether, now using Node's built-in `http` and `https` modules for better backward compatibility and support for additional [request parameters][request_opts] for [loadImage()][loadImage()]
+
+[request_opts]: https://nodejs.org/api/http.html#httprequestoptions-callback
 
 ## 📦 ⟩ [v3.0.3] ⟩ Aug 20, 2025
 

docs/api/image.md

@@ -199,11 +199,28 @@ Note that you can pass a wide variety of image sources to the `loadImage` helper
 
 #### Loading URLs
 
-When loading a URL over HTTP(S) you may also include a second argument containing [request options][fetch_opts] to be used when the library calls [`fetch`][fetch] behind the scenes. This can be useful for accessing resources requiring authentication…
+When loading a URL over HTTP(S) you may also include a second argument containing options to be used when the library makes its web request behind the scenes.
 
+The supported options include:
+- `method`: the http ‘verb’ to use (defaults to `GET`)
+- `headers`: an object mapping request header names to values
+- `body`: a string or buffer to be sent to the server if the method is set to `POST` or `PUT`
+- `auth`: credentials for Basic Auth in the format `"user:password"` which will be used to construct the `Authorization` header (if not supplied)
+- `signal`: an [AbortSignal][AbortSignal] to allow the request to be cancelled
+- `agent`: an [http.Agent][http_agent] used to customize the connection or `false` to disable the [default agent](https://www.npmjs.com/package/https-proxy-agent) which uses the url in the `HTTP_PROXY` environment variable (if defined) as a proxy server
+- any other option supported by Node’s [http.request][http_request] call
+
+
+These options can be useful for accessing resources requiring authentication…
+
+```js
+let img = await loadImage('https://example.com/lightly-protected.png', {
+  auth: "username:password" // credentials for http-basic-auth
+})
+```
 ```js
 let img = await loadImage('https://example.com/protected.png', {
-  headers: {"Authorization": 'Bearer <secret-token-value>'}
+  headers: {"Authorization": 'Bearer <secret-token-value>'} // token-based auth
 })
 ```
 
@@ -221,6 +238,8 @@ let img = await loadImage('https://example.com/customized.svg', {
 })
 ```
 
+
+
 <!-- references_begin -->
 [loadimage]: #loadimage
 [img_bind]: #on--off--once
@@ -235,8 +254,9 @@ let img = await loadImage('https://example.com/customized.svg', {
 [Buffer]: https://nodejs.org/api/buffer.html
 [sharp]: https://sharp.pixelplumbing.com
 [sharp_npm]: https://www.npmjs.com/package/sharp
-[fetch]: https://developer.mozilla.org/en-US/docs/Web/API/Window/fetch
-[fetch_opts]: https://developer.mozilla.org/en-US/docs/Web/API/RequestInit
+[http_agent]: https://nodejs.org/api/http.html#class-httpagent
+[http_request]: https://nodejs.org/api/http.html#httprequestoptions-callback
+[AbortSignal]: https://developer.mozilla.org/en-US/docs/Webhttps://developer.mozilla.org/en-US/docs/Web/API/AbortSignal
 [Promise]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise
 [DataURL]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs
 [img_element]: https://developer.mozilla.org/en-US/docs/Web/API/HTMLImageElement

docs/api/imagedata.md

@@ -177,7 +177,7 @@ let id = await loadImageData('some-image-file.raw', 64, 64, {
 ```
 
 #### Loading URLs
-If the `src` argument is a URL, you can optionally include any [request options][fetch_opts] supported by [`fetch`][fetch] in the final argument:
+If the `src` argument is a URL, you can optionally include any [supported request options][loadimage_options] in the final argument:
 ```js
 let id = await loadImageData('https://skia-canvas.org/customized.raw', 64, 64, {
   colorType: "rgb",
@@ -220,11 +220,10 @@ await loadImageData(sharpImage)
 [imgdata_colortype]: #colortype
 [imgdata_bpp]: #bytesperpixel
 [imgdata_tosharp]: #tosharp
+[loadimage_options]: image.md#loading-urls
 [skia_colortype]: https://rust-skia.github.io/doc/skia_safe/enum.ColorType.html
 [sharp]: https://sharp.pixelplumbing.com
 [sharp_npm]: https://www.npmjs.com/package/sharp
-[fetch]: https://developer.mozilla.org/en-US/docs/Web/API/Window/fetch
-[fetch_opts]: https://developer.mozilla.org/en-US/docs/Web/API/RequestInit
 [ImageData]: https://developer.mozilla.org/en-US/docs/Web/API/ImageData
 [mdn_ImageData_data]: https://developer.mozilla.org/en-US/docs/Web/API/ImageData/data
 [mdn_ImageData_colorspace]: https://developer.mozilla.org/en-US/docs/Web/API/ImageData/colorSpace

lib/classes/imagery.js

@@ -5,10 +5,9 @@
 "use strict"
 
 const {RustClass, core, readOnly, inspect, neon, argc, REPR} = require('./neon'),
-      {fetch} = require('../fetch'),
+      {fetchURL, decodeDataURL, expandURL} = require('../urls'),
       {EventEmitter} = require('events'),
-      {readFile} = require('fs/promises'),
-      url = require('url')
+      {readFile} = require('fs/promises')
 
 //
 // Image
@@ -35,7 +34,7 @@ class Image extends RustClass {
   constructor(data, src='') {
     super(Image).alloc()
 
-    data = expandURLs(data)
+    data = expandURL(data)
     this.prop("src", ''+src || '::Buffer::')
 
     if (Buffer.isBuffer(data)) {
@@ -94,7 +93,7 @@ class Image extends RustClass {
       }
     }
 
-    src = expandURLs(src)
+    src = expandURL(src)
     this.prop("src", typeof src=='string' ? src : '')
 
     fetchData(src, undefined, loaded, failed)
@@ -221,41 +220,8 @@ function isSharpImage(obj){
   }
 }
 
-const decodeDataURL = (dataURL, ok, fail) => {
-  if (typeof dataURL!='string') return fail(TypeError(`Expected a data URL string (got ${typeof dataURL})`))
-  let [header, mime, enc] = dataURL.slice(0, 40).match(/^\s*data:(?<mime>[^;]*);(?:charset=)?(?<enc>[^,]*),/) || []
-  if (!mime || !enc) return fail(TypeError(`Expected a valid data URL string (got: "${dataURL}")`))
-
-  // SVGs in particular may not be base64 encoded
-  let content = dataURL.slice(header.length)
-  if (enc.toLowerCase() != 'base64') content = decodeURIComponent(content)
-
-  try{ ok(Buffer.from(content, enc)) }
-  catch(e){ fail(e) }
-}
-
-const fetchURL = (url, fetchOpts, ok, fail) => {
-  fetch(url, fetchOpts)
-    .then(resp => {
-      if (resp.ok) return resp.arrayBuffer()
-      else throw new Error(`Failed to load image from "${url}" (HTTP error ${resp.status})`)
-    })
-    .then(buf => ok(Buffer.from(buf)))
-    .catch(err => fail(err))
-}
-
-const expandURLs = (src) => {
-  // convert URLs to strings, otherwise pass arg through unmodified
-  if (src instanceof URL){
-    if (src.protocol=='file:') src = url.fileURLToPath(src)
-    else if (src.protocol.match(/^(https?|data):/)) src = src.href
-    else throw Error(`Unsupported protocol: ${src.protocol.replace(':', '')}`)
-  }
-  return src
-}
-
-const fetchData = (src, fetchOpts, loaded, failed) => {
-  src = expandURLs(src)
+const fetchData = (src, reqOpts, loaded, failed) => {
+  src = expandURL(src)
   if (Buffer.isBuffer(src)) {
     loaded(src, '::Buffer::')
   }else if (isSharpImage(src)){
@@ -272,7 +238,7 @@ const fetchData = (src, fetchOpts, loaded, failed) => {
         err =>  failed(err),
       )
     }else if (/^\s*https?:\/\//.test(src)){
-      fetchURL(src, fetchOpts,
+      fetchURL(src, reqOpts,
         buffer => loaded(buffer, src),
         err => failed(err)
       )

lib/fetch.js

@@ -0,0 +1,61 @@
+const url = require('url'),
+      {http, https} = require('follow-redirects'),
+      {HttpsProxyAgent} = require('https-proxy-agent')
+
+const UA = {"User-Agent": "Skia Canvas"}
+const PROXY_URL =
+  process.env.https_proxy || process.env.HTTPS_PROXY ||
+  process.env.http_proxy || process.env.HTTP_PROXY
+
+const fetchURL = (url, opts, ok, fail) => {
+  let proto = url.slice(0,5).split(':')[0],
+      client = {http, https}[proto.toLowerCase()]
+
+  if (!client){
+    fail(new Error(`Unsupported protocol: expected 'http' or 'https' (got: ${proto})`))
+  }else{
+    opts = opts || {}
+    opts.headers = {...UA, ...opts.headers}
+    opts.agent = opts.agent===undefined && PROXY_URL ? new HttpsProxyAgent(PROXY_URL) : opts.agent
+
+    let req = client.request(url, opts, resp => {
+      if (resp.statusCode < 200 || resp.statusCode >= 300){
+        fail(new Error(`Failed to load image from "${url}" (HTTP error ${resp.statusCode})`))
+      }else{
+        const chunks = []
+        resp.on("data", chunk => chunks.push(chunk))
+        resp.on("end", () => ok(Buffer.concat(chunks)))
+        resp.on('error', e => fail(e))
+      }
+    })
+
+    req.on('error', e => fail(e))
+    if (opts.body) req.write(opts.body)
+    req.end()
+  }
+}
+
+const decodeDataURL = (dataURL, ok, fail) => {
+  if (typeof dataURL!='string') return fail(TypeError(`Expected a data URL string (got ${typeof dataURL})`))
+  let [header, mime, enc] = dataURL.slice(0, 40).match(/^\s*data:(?<mime>[^;]*);(?:charset=)?(?<enc>[^,]*),/) || []
+  if (!mime || !enc) return fail(TypeError(`Expected a valid data URL string (got: "${dataURL}")`))
+
+  // SVGs in particular may not be base64 encoded
+  let content = dataURL.slice(header.length)
+  if (enc.toLowerCase() != 'base64') content = decodeURIComponent(content)
+
+  try{ ok(Buffer.from(content, enc)) }
+  catch(e){ fail(e) }
+}
+
+const expandURL = (src) => {
+  // convert URLs to strings, otherwise pass arg through unmodified
+  if (src instanceof URL){
+    if (src.protocol=='file:') src = url.fileURLToPath(src)
+    else if (src.protocol.match(/^(https?|data):/)) src = src.href
+    else throw Error(`Unsupported protocol: ${src.protocol.replace(':', '')}`)
+  }
+  return src
+}
+
+module.exports = {fetchURL, decodeDataURL, expandURL}