Remove idempotent property of encoding

The idea was that, if we knew that encode() and decode() were
idempotent, we could in certain situations skip a decode step in
abstract-leveldown and avoid allocating a callback function. For
example if leveldown returned a string to be decoded with the utf8
encoding; that would be a noop we could skip.

It worked fine. But I didn't get to test that it had a significant
performance benefit. And to avoid painting ourselves into a corner
with this optimization (for example, if we need to normalize data in
decode() like level-js does) I'm not gonna spend more time on it.

Author: vweevers

lib/encoding.d.ts

@@ -16,14 +16,11 @@ export abstract class Encoding<TIn, TFormat, TOut> {
   /** Unique name for this encoding. */
   type: string
 
-  /** Format returned by {@link encode}. */
-  format: string
-
   /**
-   * Whether {@link encode} and {@link decode} are idempotent
-   * functions, such that `f(x) == f(f(x))`.
+   * Indicates the (lower-level) encoding used by the return value
+   * of {@link encode}. Typically one of 'buffer', 'view', 'utf8'.
    */
-  idempotent: boolean
+  format: string
 
   createViewTranscoder (): ViewFormat<TIn, TOut> | undefined
   createBufferTranscoder (): BufferFormat<TIn, TOut> | undefined
@@ -53,7 +50,8 @@ export interface EncodingOptions<TIn, TFormat, TOut> {
   type?: string | undefined
 
   /**
-   * Format returned by {@link encode}.
+   * Indicates the (lower-level) encoding used by the return value
+   * of {@link encode}. Typically one of 'buffer', 'view', 'utf8'.
    */
   format?: string | undefined
 

lib/encoding.js

@@ -47,9 +47,6 @@ class Encoding {
     /** @type {string} */
     this.format = format || (buffer === false ? 'utf8' : 'buffer')
 
-    /** @type {boolean} */
-    this.idempotent = this.type === this.format
-
     if (createViewTranscoder) {
       this.createViewTranscoder = createViewTranscoder
     }

test/transcoder.js

@@ -182,11 +182,10 @@ test('transcoder.encoding() wraps custom anonymous encoding', function (t) {
   const transcoder = new Transcoder(['buffer', 'view', 'utf8'])
   const spy = (v) => v + 1
   const opts = { encode: spy, decode: spy }
-  const verify = (encoding, idempotent) => {
+  const verify = (encoding) => {
     t.is(encoding.encode(1), 2, 'has encode() function')
     t.is(encoding.decode(1), 2, 'has decode() function')
     t.ok(/^anonymous-\d+$/.test(encoding.type), 'is anonymous: ' + encoding.type)
-    t.is(encoding.idempotent, idempotent, 'idempotent: ' + idempotent)
     t.is(encoding.buffer, undefined, 'does not expose legacy buffer option')
   }
 
@@ -216,16 +215,3 @@ test('transcoder.encoding() wraps custom anonymous encoding', function (t) {
 
   t.end()
 })
-
-test('has idempotent properties', function (t) {
-  const transcoder = new Transcoder(['buffer', 'view', 'utf8', 'id'])
-
-  t.is(transcoder.encoding('buffer').idempotent, true)
-  t.is(transcoder.encoding('view').idempotent, true)
-  t.is(transcoder.encoding('utf8').idempotent, true)
-  t.is(transcoder.encoding('id').idempotent, true)
-  t.is(transcoder.encoding('json').idempotent, false)
-  t.is(transcoder.encoding('base64').idempotent, false)
-  t.is(transcoder.encoding('hex').idempotent, false)
-  t.end()
-})