bare-media 1.2.1 → 1.4.0

package/README.md

@@ -29,15 +29,14 @@ const data = await worker.createPreview({ path, maxWidth, maxHeight })
 
 > NOTE: A worker spawns when an operation is requested and it stays running until the parent process is killed.
 
-Handle close event:
+Terminate the worker:
 
 ```js
-import worker from 'bare-media'
+worker.close()
 
 worker.onClose = () => {
-  // worker closed unexpectedly
+  // worker terminated
 }
-
 ```
 
 Call the methods directly without a worker:
@@ -50,13 +49,33 @@ const data = await createPreview({ path, maxWidth, maxHeight })
 
 ## API
 
-| Method              | Parameters                                              | Return Value        | Description
-|---------------------|---------------------------------------------------------|---------------------|----------------------------------------
-| `createPreview`     | `path, mimetype, maxWidth, maxHeight, format, encoding` | `metadata, preview` | Create a preview from a media file
-| `decodeImage`       | `path`, `httpLink, mimetype`                            | `metadata, data`    | Decode an image to RGBA
-
 > See [schema.js](shared/spec/schema.js) for the complete reference of parameters
 
+### createPreview()
+
+Create a preview from a media file
+
+| Property    | Type   | Description                                                       |
+| ----------- | ------ | ----------------------------------------------------------------- |
+| `path`      | string | Path to the input file                                            |
+| `mimetype`  | string | Media type of the input file. If not provided it will be detected |
+| `maxWidth`  | number | Max width for the generated preview                               |
+| `maxHeight` | number | Max height for the generated preview                              |
+| `maxFrames` | number | Max frames for the generated preview in case the file is animated |
+| `maxBytes`  | number | Max bytes for the generated preview                               |
+| `format`    | string | Media type for the generated preview. Default `image/webp`        |
+| `encoding`  | string | `base64` or nothing for buffer                                    |
+
+### decodeImage()
+
+Decode an image to RGBA
+
+| Property   | Type   | Description                                                       |
+| ---------- | ------ | ----------------------------------------------------------------- |
+| `path`     | string | Path to the input file. Either this or `httpLink` is required     |
+| `httpLink` | string | Http link to the input file                                       |
+| `mimetype` | string | Media type of the input file. If not provided it will be detected |
+
 ## License
 
 Apache-2.0

package/client.js

@@ -9,21 +9,22 @@ export class WorkerClient extends ReadyResource {
   rpc = null
   opts = null
 
-  constructor (opts) {
+  constructor(opts) {
     super()
     this.initialize(opts)
     this.#attachMethods()
   }
 
-  initialize ({ filename = 'node_modules/bare-media/worker/index.js', requireSource, args } = {}) {
+  initialize({
+    filename = 'node_modules/bare-media/worker/index.js',
+    requireSource,
+    args
+  } = {}) {
     this.opts = { filename, requireSource, args }
   }
 
-  #attachMethods () {
-    const methods = [
-      'createPreview',
-      'decodeImage'
-    ]
+  #attachMethods() {
+    const methods = ['createPreview', 'decodeImage']
 
     for (const method of methods) {
       this[method] = async (...args) => {
@@ -33,15 +34,15 @@ export class WorkerClient extends ReadyResource {
     }
   }
 
-  async _open () {
+  async _open() {
     await this.#run()
   }
 
-  async _close () {
+  async _close() {
     this.worker?.IPC.end()
   }
 
-  async #run () {
+  async #run() {
     const { filename, requireSource, args } = this.opts
     const source = requireSource?.()
     this.worker = await spawn(filename, source, args)
@@ -54,7 +55,7 @@ export class WorkerClient extends ReadyResource {
     this.rpc = new HRPC(ipc)
   }
 
-  isCodecSupported (mimetype) {
+  isCodecSupported(mimetype) {
     return isCodecSupported(mimetype)
   }
 }

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "bare-media",
-  "version": "1.2.1",
+  "version": "1.4.0",
   "main": "index.js",
   "type": "module",
   "scripts": {
     "build:rpc": "cd shared/spec && bare ./build.js",
-    "lint": "standard",
-    "lint:fix": "standard --fix",
-    "test": "npm run lint && brittle-bare test/index.js"
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "test": "npm run format:check && brittle-bare test/index.js"
   },
   "keywords": [],
   "author": "Holepunch Inc",
@@ -35,7 +35,8 @@
     "corestore": "^7.4.5",
     "hyperblobs": "^2.8.0",
     "hypercore-blob-server": "^1.11.0",
-    "standard": "^17.1.2",
+    "prettier": "^3.6.2",
+    "prettier-config-holepunch": "^1.0.0",
     "test-tmp": "^1.4.0"
   },
   "files": [
@@ -43,11 +44,5 @@
     "worker",
     "client.js",
     "index.js"
-  ],
-  "standard": {
-    "globals": [
-      "Bare",
-      "Pear"
-    ]
-  }
+  ]
 }

package/shared/codecs.js

@@ -10,12 +10,16 @@ export const codecs = {
   'image/tiff': () => import('bare-tiff')
 }
 
-export function isCodecSupported (mimetype) {
+export function isCodecSupported(mimetype) {
   return mimetype in codecs
 }
 
-export async function importCodec (mimetype) {
+export async function importCodec(mimetype) {
   const codecImport = codecs[mimetype]
   if (!codecImport) throw new Error(`No codec for ${mimetype}`)
   return await codecImport()
 }
+
+export function supportsQuality(mimetype) {
+  return { 'image/webp': true, 'image/jpeg': true }[mimetype] || false
+}

package/shared/spec/hrpc/hrpc.json

@@ -28,4 +28,4 @@
       "version": 1
     }
   ]
-}
+}

package/shared/spec/hrpc/index.js

@@ -1,5 +1,6 @@
 // This file is autogenerated by the hrpc compiler
 /* eslint-disable camelcase */
+/* eslint-disable space-before-function-paren */
 
 import { c, RPC, RPCStream, RPCRequestStream } from 'hrpc/runtime'
 import { getEncoding } from './messages.js'
@@ -12,7 +13,7 @@ const methods = new Map([
 ])
 
 class HRPC {
-  constructor (stream) {
+  constructor(stream) {
     this._stream = stream
     this._handlers = []
     this._requestEncodings = new Map([
@@ -39,23 +40,40 @@ class HRPC {
       }
       if (!this._requestIsStream(command) && this._responseIsStream(command)) {
         const request = req.data ? c.decode(requestEncoding, req.data) : null
-        const responseStream = new RPCStream(null, null, req.createResponseStream(), responseEncoding)
+        const responseStream = new RPCStream(
+          null,
+          null,
+          req.createResponseStream(),
+          responseEncoding
+        )
         responseStream.data = request
         await this._handlers[command](responseStream)
       }
       if (this._requestIsStream(command) && !this._responseIsStream(command)) {
-        const requestStream = new RPCRequestStream(req, responseEncoding, req.createRequestStream(), requestEncoding)
+        const requestStream = new RPCRequestStream(
+          req,
+          responseEncoding,
+          req.createRequestStream(),
+          requestEncoding
+        )
         const response = await this._handlers[command](requestStream)
         req.reply(c.encode(responseEncoding, response))
       }
       if (this._requestIsStream(command) && this._responseIsStream(command)) {
-        const requestStream = new RPCRequestStream(req, responseEncoding, req.createRequestStream(), requestEncoding, req.createResponseStream(), responseEncoding)
+        const requestStream = new RPCRequestStream(
+          req,
+          responseEncoding,
+          req.createRequestStream(),
+          requestEncoding,
+          req.createResponseStream(),
+          responseEncoding
+        )
         await this._handlers[command](requestStream)
       }
     })
   }
 
-  async _call (name, args) {
+  async _call(name, args) {
     const requestEncoding = this._requestEncodings.get(name)
     const responseEncoding = this._responseEncodings.get(name)
     const request = this._rpc.request(methods.get(name))
@@ -64,7 +82,7 @@ class HRPC {
     return c.decode(responseEncoding, await request.reply())
   }
 
-  _callSync (name, args) {
+  _callSync(name, args) {
     const requestEncoding = this._requestEncodings.get(name)
     const responseEncoding = this._responseEncodings.get(name)
     const request = this._rpc.request(methods.get(name))
@@ -78,41 +96,55 @@ class HRPC {
       return new RPCStream(request.createResponseStream(), responseEncoding)
     }
     if (this._requestIsStream(name) && !this._responseIsStream(name)) {
-      return new RPCRequestStream(request, responseEncoding, null, null, request.createRequestStream(), requestEncoding)
+      return new RPCRequestStream(
+        request,
+        responseEncoding,
+        null,
+        null,
+        request.createRequestStream(),
+        requestEncoding
+      )
     }
     if (this._requestIsStream(name) && this._responseIsStream(name)) {
-      return new RPCRequestStream(request, responseEncoding, request.createResponseStream(), responseEncoding, request.createRequestStream(), requestEncoding)
+      return new RPCRequestStream(
+        request,
+        responseEncoding,
+        request.createResponseStream(),
+        responseEncoding,
+        request.createRequestStream(),
+        requestEncoding
+      )
     }
   }
 
-  async createPreview (args) {
+  async createPreview(args) {
     return this._call('@media/create-preview', args)
   }
 
-  async decodeImage (args) {
+  async decodeImage(args) {
     return this._call('@media/decode-image', args)
   }
 
-  onCreatePreview (responseFn) {
+  onCreatePreview(responseFn) {
     this._handlers['@media/create-preview'] = responseFn
   }
 
-  onDecodeImage (responseFn) {
+  onDecodeImage(responseFn) {
     this._handlers['@media/decode-image'] = responseFn
   }
 
-  _requestIsStream (command) {
-    return [
-    ].includes(command)
+  _requestIsStream(command) {
+    return [].includes(command)
   }
 
-  _responseIsStream (command) {
-    return [
-    ].includes(command)
+  _responseIsStream(command) {
+    return [].includes(command)
   }
 
-  _requestIsSend (command) {
+  // prettier-ignore-start
+  _requestIsSend(command) {
     return [
+      // prettier-ignore
     ].includes(command)
   }
 }

package/shared/spec/hrpc/messages.js

@@ -12,15 +12,15 @@ let version = VERSION
 
 // @media/dimensions
 const encoding0 = {
-  preencode (state, m) {
+  preencode(state, m) {
     c.uint.preencode(state, m.width)
     c.uint.preencode(state, m.height)
   },
-  encode (state, m) {
+  encode(state, m) {
     c.uint.encode(state, m.width)
     c.uint.encode(state, m.height)
   },
-  decode (state) {
+  decode(state) {
     const r0 = c.uint.decode(state)
     const r1 = c.uint.decode(state)
 
@@ -36,18 +36,16 @@ const encoding1_1 = c.frame(encoding0)
 
 // @media/metadata
 const encoding1 = {
-  preencode (state, m) {
+  preencode(state, m) {
     state.end++ // max flag is 4 so always one byte
 
     if (m.mimetype) c.string.preencode(state, m.mimetype)
     if (m.dimensions) encoding1_1.preencode(state, m.dimensions)
     if (m.duration) c.uint.preencode(state, m.duration)
   },
-  encode (state, m) {
+  encode(state, m) {
     const flags =
-      (m.mimetype ? 1 : 0) |
-      (m.dimensions ? 2 : 0) |
-      (m.duration ? 4 : 0)
+      (m.mimetype ? 1 : 0) | (m.dimensions ? 2 : 0) | (m.duration ? 4 : 0)
 
     c.uint.encode(state, flags)
 
@@ -55,7 +53,7 @@ const encoding1 = {
     if (m.dimensions) encoding1_1.encode(state, m.dimensions)
     if (m.duration) c.uint.encode(state, m.duration)
   },
-  decode (state) {
+  decode(state) {
     const flags = c.uint.decode(state)
 
     return {
@@ -71,18 +69,16 @@ const encoding2_0 = c.frame(encoding1)
 
 // @media/file
 const encoding2 = {
-  preencode (state, m) {
+  preencode(state, m) {
     state.end++ // max flag is 4 so always one byte
 
     if (m.metadata) encoding2_0.preencode(state, m.metadata)
     if (m.inlined) c.string.preencode(state, m.inlined)
     if (m.buffer) c.buffer.preencode(state, m.buffer)
   },
-  encode (state, m) {
+  encode(state, m) {
     const flags =
-      (m.metadata ? 1 : 0) |
-      (m.inlined ? 2 : 0) |
-      (m.buffer ? 4 : 0)
+      (m.metadata ? 1 : 0) | (m.inlined ? 2 : 0) | (m.buffer ? 4 : 0)
 
     c.uint.encode(state, flags)
 
@@ -90,7 +86,7 @@ const encoding2 = {
     if (m.inlined) c.string.encode(state, m.inlined)
     if (m.buffer) c.buffer.encode(state, m.buffer)
   },
-  decode (state) {
+  decode(state) {
     const flags = c.uint.decode(state)
 
     return {
@@ -103,23 +99,27 @@ const encoding2 = {
 
 // @media/create-preview-request
 const encoding3 = {
-  preencode (state, m) {
+  preencode(state, m) {
     c.string.preencode(state, m.path)
-    state.end++ // max flag is 16 so always one byte
+    state.end++ // max flag is 64 so always one byte
 
     if (m.mimetype) c.string.preencode(state, m.mimetype)
     if (m.maxWidth) c.uint.preencode(state, m.maxWidth)
     if (m.maxHeight) c.uint.preencode(state, m.maxHeight)
+    if (m.maxFrames) c.uint.preencode(state, m.maxFrames)
+    if (m.maxBytes) c.uint.preencode(state, m.maxBytes)
     if (m.format) c.string.preencode(state, m.format)
     if (m.encoding) c.string.preencode(state, m.encoding)
   },
-  encode (state, m) {
+  encode(state, m) {
     const flags =
       (m.mimetype ? 1 : 0) |
       (m.maxWidth ? 2 : 0) |
       (m.maxHeight ? 4 : 0) |
-      (m.format ? 8 : 0) |
-      (m.encoding ? 16 : 0)
+      (m.maxFrames ? 8 : 0) |
+      (m.maxBytes ? 16 : 0) |
+      (m.format ? 32 : 0) |
+      (m.encoding ? 64 : 0)
 
     c.string.encode(state, m.path)
     c.uint.encode(state, flags)
@@ -127,10 +127,12 @@ const encoding3 = {
     if (m.mimetype) c.string.encode(state, m.mimetype)
     if (m.maxWidth) c.uint.encode(state, m.maxWidth)
     if (m.maxHeight) c.uint.encode(state, m.maxHeight)
+    if (m.maxFrames) c.uint.encode(state, m.maxFrames)
+    if (m.maxBytes) c.uint.encode(state, m.maxBytes)
     if (m.format) c.string.encode(state, m.format)
     if (m.encoding) c.string.encode(state, m.encoding)
   },
-  decode (state) {
+  decode(state) {
     const r0 = c.string.decode(state)
     const flags = c.uint.decode(state)
 
@@ -139,8 +141,10 @@ const encoding3 = {
       mimetype: (flags & 1) !== 0 ? c.string.decode(state) : null,
       maxWidth: (flags & 2) !== 0 ? c.uint.decode(state) : 0,
       maxHeight: (flags & 4) !== 0 ? c.uint.decode(state) : 0,
-      format: (flags & 8) !== 0 ? c.string.decode(state) : null,
-      encoding: (flags & 16) !== 0 ? c.string.decode(state) : null
+      maxFrames: (flags & 8) !== 0 ? c.uint.decode(state) : 0,
+      maxBytes: (flags & 16) !== 0 ? c.uint.decode(state) : 0,
+      format: (flags & 32) !== 0 ? c.string.decode(state) : null,
+      encoding: (flags & 64) !== 0 ? c.string.decode(state) : null
     }
   }
 }
@@ -152,15 +156,15 @@ const encoding4_1 = c.frame(encoding2)
 
 // @media/create-preview-response
 const encoding4 = {
-  preencode (state, m) {
+  preencode(state, m) {
     encoding4_0.preencode(state, m.metadata)
     encoding4_1.preencode(state, m.preview)
   },
-  encode (state, m) {
+  encode(state, m) {
     encoding4_0.encode(state, m.metadata)
     encoding4_1.encode(state, m.preview)
   },
-  decode (state) {
+  decode(state) {
     const r0 = encoding4_0.decode(state)
     const r1 = encoding4_1.decode(state)
 
@@ -173,18 +177,15 @@ const encoding4 = {
 
 // @media/decode-image-request
 const encoding5 = {
-  preencode (state, m) {
+  preencode(state, m) {
     state.end++ // max flag is 4 so always one byte
 
     if (m.path) c.string.preencode(state, m.path)
     if (m.httpLink) c.string.preencode(state, m.httpLink)
     if (m.mimetype) c.string.preencode(state, m.mimetype)
   },
-  encode (state, m) {
-    const flags =
-      (m.path ? 1 : 0) |
-      (m.httpLink ? 2 : 0) |
-      (m.mimetype ? 4 : 0)
+  encode(state, m) {
+    const flags = (m.path ? 1 : 0) | (m.httpLink ? 2 : 0) | (m.mimetype ? 4 : 0)
 
     c.uint.encode(state, flags)
 
@@ -192,7 +193,7 @@ const encoding5 = {
     if (m.httpLink) c.string.encode(state, m.httpLink)
     if (m.mimetype) c.string.encode(state, m.mimetype)
   },
-  decode (state) {
+  decode(state) {
     const flags = c.uint.decode(state)
 
     return {
@@ -208,23 +209,21 @@ const encoding6_0 = encoding2_0
 
 // @media/decode-image-response
 const encoding6 = {
-  preencode (state, m) {
+  preencode(state, m) {
     state.end++ // max flag is 2 so always one byte
 
     if (m.metadata) encoding6_0.preencode(state, m.metadata)
     if (m.data) c.buffer.preencode(state, m.data)
   },
-  encode (state, m) {
-    const flags =
-      (m.metadata ? 1 : 0) |
-      (m.data ? 2 : 0)
+  encode(state, m) {
+    const flags = (m.metadata ? 1 : 0) | (m.data ? 2 : 0)
 
     c.uint.encode(state, flags)
 
     if (m.metadata) encoding6_0.encode(state, m.metadata)
     if (m.data) c.buffer.encode(state, m.data)
   },
-  decode (state) {
+  decode(state) {
     const flags = c.uint.decode(state)
 
     return {
@@ -234,51 +233,60 @@ const encoding6 = {
   }
 }
 
-function setVersion (v) {
+function setVersion(v) {
   version = v
 }
 
-function encode (name, value, v = VERSION) {
+function encode(name, value, v = VERSION) {
   version = v
   return c.encode(getEncoding(name), value)
 }
 
-function decode (name, buffer, v = VERSION) {
+function decode(name, buffer, v = VERSION) {
   version = v
   return c.decode(getEncoding(name), buffer)
 }
 
-function getEnum (name) {
+function getEnum(name) {
   switch (name) {
-    default: throw new Error('Enum not found ' + name)
+    default:
+      throw new Error('Enum not found ' + name)
   }
 }
 
-function getEncoding (name) {
+function getEncoding(name) {
   switch (name) {
-    case '@media/dimensions': return encoding0
-    case '@media/metadata': return encoding1
-    case '@media/file': return encoding2
-    case '@media/create-preview-request': return encoding3
-    case '@media/create-preview-response': return encoding4
-    case '@media/decode-image-request': return encoding5
-    case '@media/decode-image-response': return encoding6
-    default: throw new Error('Encoder not found ' + name)
+    case '@media/dimensions':
+      return encoding0
+    case '@media/metadata':
+      return encoding1
+    case '@media/file':
+      return encoding2
+    case '@media/create-preview-request':
+      return encoding3
+    case '@media/create-preview-response':
+      return encoding4
+    case '@media/decode-image-request':
+      return encoding5
+    case '@media/decode-image-response':
+      return encoding6
+    default:
+      throw new Error('Encoder not found ' + name)
   }
 }
 
-function getStruct (name, v = VERSION) {
+function getStruct(name, v = VERSION) {
   const enc = getEncoding(name)
   return {
-    preencode (state, m) {
+    preencode(state, m) {
       version = v
       enc.preencode(state, m)
     },
-    encode (state, m) {
+    encode(state, m) {
       version = v
       enc.encode(state, m)
     },
-    decode (state) {
+    decode(state) {
       version = v
       return enc.decode(state)
     }
@@ -287,4 +295,13 @@ function getStruct (name, v = VERSION) {
 
 const resolveStruct = getStruct // compat
 
-export { resolveStruct, getStruct, getEnum, getEncoding, encode, decode, setVersion, version }
+export {
+  resolveStruct,
+  getStruct,
+  getEnum,
+  getEncoding,
+  encode,
+  decode,
+  setVersion,
+  version
+}