Use bare-type

binding.c

@@ -138,29 +138,6 @@ bare_structured_clone_detach_arraybuffer (js_env_t *env, js_callback_info_t *inf
   return NULL;
 }
 
-static js_value_t *
-bare_structured_clone_is_external (js_env_t *env, js_callback_info_t *info) {
-  int err;
-
-  size_t argc = 1;
-  js_value_t *argv[1];
-
-  err = js_get_callback_info(env, info, &argc, argv, NULL, NULL);
-  assert(err == 0);
-
-  assert(argc == 1);
-
-  bool is_external;
-  err = js_is_external(env, argv[0], &is_external);
-  assert(err == 0);
-
-  js_value_t *result;
-  err = js_get_boolean(env, is_external, &result);
-  assert(err == 0);
-
-  return result;
-}
-
 static js_value_t *
 bare_structured_clone_get_external (js_env_t *env, js_callback_info_t *info) {
   int err;
@@ -212,7 +189,7 @@ bare_structured_clone_create_external (js_env_t *env, js_callback_info_t *info)
 }
 
 static js_value_t *
-init (js_env_t *env, js_value_t *exports) {
+bare_structured_clone_exports (js_env_t *env, js_value_t *exports) {
   int err;
 
 #define V(name, fn) \
@@ -229,12 +206,11 @@ init (js_env_t *env, js_value_t *exports) {
   V("createArrayBuffer", bare_structured_clone_create_arraybuffer)
   V("createSharedArrayBuffer", bare_structured_clone_create_sharedarraybuffer)
   V("detachArrayBuffer", bare_structured_clone_detach_arraybuffer)
-  V("isExternal", bare_structured_clone_is_external)
   V("getExternal", bare_structured_clone_get_external)
   V("createExternal", bare_structured_clone_create_external)
 #undef V
 
   return exports;
 }
 
-BARE_MODULE(bare_structured_clone, init)
+BARE_MODULE(bare_structured_clone, bare_structured_clone_exports)

index.js

@@ -1,3 +1,4 @@
+const getType = require('bare-type')
 const c = require('compact-encoding')
 const bitfield = require('compact-encoding-bitfield')
 const bits = require('bits-to-bytes')
@@ -110,19 +111,18 @@ class ReferenceMap {
 }
 
 function serializeValue (value, forStorage, interfaces, references) {
-  switch (typeof value) {
-    case 'undefined': return { type: t.UNDEFINED }
-    case 'boolean': return { type: value ? t.TRUE : t.FALSE }
-    case 'number': return { type: t.NUMBER, value }
-    case 'bigint': return { type: t.BIGINT, value }
-    case 'string': return serializeString(value)
-    case 'symbol': return serializeSymbol(value)
-    case 'function': return serializeFunction(value)
-  }
-
-  if (value === null) return { type: t.NULL }
-
-  return serializeReferenceable(value, forStorage, interfaces, references)
+  const type = getType(value)
+
+  if (type.isUndefined()) return { type: t.UNDEFINED }
+  if (type.isNull()) return { type: t.NULL }
+  if (type.isBoolean()) return { type: value ? t.TRUE : t.FALSE }
+  if (type.isNumber()) return { type: t.NUMBER, value }
+  if (type.isBigInt()) return { type: t.BIGINT, value }
+  if (type.isString()) return serializeString(value)
+  if (type.isSymbol()) return serializeSymbol(value)
+  if (type.isObject()) return serializeReferenceable(type, value, forStorage, interfaces, references)
+  if (type.isFunction()) return serializeFunction(value)
+  if (type.isExternal()) return serializeExternal(value, forStorage, references)
 }
 
 function serializeString (value) {
@@ -137,28 +137,29 @@ function serializeFunction (value) {
   throw errors.UNSERIALIZABLE_TYPE(`Function '${value.name}' cannot be serialized`)
 }
 
-function serializeReferenceable (value, forStorage, interfaces, references) {
+function serializeReferenceable (type, value, forStorage, interfaces, references) {
   if (references.has(value)) return serializeReference(value, references)
 
-  if (value instanceof Date) return serializeDate(value, references)
-  if (value instanceof RegExp) return serializeRegExp(value, references)
-  if (value instanceof Error) return serializeError(value, forStorage, interfaces, references)
-  if (value instanceof ArrayBuffer) return serializeArrayBuffer(value, references)
-  if (value instanceof SharedArrayBuffer) return serializeSharedArrayBuffer(value, forStorage, references)
-  if (value instanceof DataView) return serializeDataView(value, forStorage, interfaces, references)
-  if (value instanceof Buffer) return serializeBuffer(value, forStorage, interfaces, references)
-  if (ArrayBuffer.isView(value)) return serializeTypedArray(value, forStorage, interfaces, references)
-  if (value instanceof Map) return serializeMap(value, forStorage, interfaces, references)
-  if (value instanceof Set) return serializeSet(value, forStorage, interfaces, references)
-  if (value instanceof Array) return serializeArray(value, forStorage, interfaces, references)
   if (value instanceof URL) return serializeURL(value, references)
-  if (binding.isExternal(value)) return serializeExternal(value, forStorage, interfaces, references)
+  if (value instanceof Buffer) return serializeBuffer(value, forStorage, interfaces, references)
+
+  if (type.isArray()) return serializeArray(value, forStorage, interfaces, references)
+  if (type.isDate()) return serializeDate(value, references)
+  if (type.isRegExp()) return serializeRegExp(value, references)
+  if (type.isError()) return serializeError(value, forStorage, interfaces, references)
+  if (type.isMap()) return serializeMap(value, forStorage, interfaces, references)
+  if (type.isSet()) return serializeSet(value, forStorage, interfaces, references)
+  if (type.isArrayBuffer()) return serializeArrayBuffer(value, references)
+  if (type.isSharedArrayBuffer()) return serializeSharedArrayBuffer(value, forStorage, references)
+  if (type.isTypedArray()) return serializeTypedArray(type, value, forStorage, interfaces, references)
+  if (type.isDataView()) return serializeDataView(value, forStorage, interfaces, references)
 
   if (
-    value instanceof Promise ||
-    value instanceof WeakMap ||
-    value instanceof WeakSet ||
-    value instanceof WeakRef
+    type.isPromise() ||
+    type.isProxy() ||
+    type.isWeakMap() ||
+    type.isWeakSet() ||
+    type.isWeakRef()
   ) {
     throw errors.UNSERIALIZABLE_TYPE(`${value.constructor.name} cannot be serialized`)
   }
@@ -278,30 +279,30 @@ function serializeSharedArrayBuffer (value, forStorage, references) {
   }
 }
 
-function serializeTypedArray (value, forStorage, interfaces, references) {
+function serializeTypedArray (type, value, forStorage, interfaces, references) {
   let view
 
-  if (value instanceof Uint8Array) {
+  if (type.isUint8Array()) {
     view = t.typedarray.UINT8ARRAY
-  } else if (value instanceof Uint8ClampedArray) {
+  } else if (type.isUint8ClampedArray()) {
     view = t.typedarray.UINT8CLAMPEDARRAY
-  } else if (value instanceof Int8Array) {
+  } else if (type.isInt8Array()) {
     view = t.typedarray.INT8ARRAY
-  } else if (value instanceof Uint16Array) {
+  } else if (type.isUint16Array()) {
     view = t.typedarray.UINT16ARRAY
-  } else if (value instanceof Int16Array) {
+  } else if (type.isInt16Array()) {
     view = t.typedarray.INT16ARRAY
-  } else if (value instanceof Uint32Array) {
+  } else if (type.isUint32Array()) {
     view = t.typedarray.UINT32ARRAY
-  } else if (value instanceof Int32Array) {
+  } else if (type.isInt32Array()) {
     view = t.typedarray.INT32ARRAY
-  } else if (value instanceof BigUint64Array) {
+  } else if (type.isBigUint64Array()) {
     view = t.typedarray.BIGUINT64ARRAY
-  } else if (value instanceof BigInt64Array) {
+  } else if (type.isBigInt64Array()) {
     view = t.typedarray.BIGINT64ARRAY
-  } else if (value instanceof Float32Array) {
+  } else if (type.isFloat32Array()) {
     view = t.typedarray.FLOAT32ARRAY
-  } else if (value instanceof Float64Array) {
+  } else if (type.isFloat64Array()) {
     view = t.typedarray.FLOAT64ARRAY
   }
 
@@ -428,7 +429,9 @@ function serializeValueWithTransfer (value, transferList, interfaces) {
   const references = new ReferenceMap()
 
   for (const transferable of transferList) {
-    if (transferable instanceof ArrayBuffer) {
+    const type = getType(transferable)
+
+    if (type.isArrayBuffer()) {
       if (transferable.detached) {
         throw errors.UNTRANSFERABLE_TYPE('Detached \'ArrayBuffer\' cannot be transferred')
       }
@@ -462,7 +465,9 @@ function serializeValueWithTransfer (value, transferList, interfaces) {
   const transfers = []
 
   for (const transferable of transferList) {
-    if (transferable instanceof ArrayBuffer) {
+    const type = getType(transferable)
+
+    if (type.isArrayBuffer()) {
       if (transferable.detached) {
         throw errors.UNTRANSFERABLE_TYPE('Detached ArrayBuffer cannot be transferred')
       }

package.json

@@ -31,6 +31,7 @@
   },
   "homepage": "https://github.com/holepunchto/bare-structured-clone#readme",
   "dependencies": {
+    "bare-type": "^1.0.0",
     "bits-to-bytes": "^1.3.0",
     "compact-encoding": "^2.15.0",
     "compact-encoding-bitfield": "^1.0.0"