mirror of
https://github.com/zebrajr/node.git
synced 2025-12-06 12:20:27 +01:00
f2c0258b4c
Adds a new `makeTransferable()` utility that can construct a
`JSTransferable` object that does not directly extend the
`JSTransferable` JavaScript class.
Because JavaScript does not support multiple inheritance, it is
not possible (without help) to implement a class that extends
both `JSTransferable` and, for instance, `EventTarget` without
incurring a significant additional complexity and performance
cost by making all `EventTarget` instances extend `JSTransferable`...
That is, we *don't* want:
```js
class EventTarget extends JSTransferable { ... }
```
The `makeTransferable()` allows us to create objects that are
backed internally by `JSTransferable` without having to actually
extend it by leveraging the magic of `Reflect.construct()`.
```js
const {
JSTransferable,
kClone,
kDeserialize,
kConstructor,
makeTransferable,
} = require('internal/worker/js_transferable');
class E {
constructor(b) {
this.b = b;
}
}
class F extends E {
[kClone]() { /** ... **/ }
[kDeserialize]() { /** ... **/ }
static [kConstructor]() { return makeTransferable(F); }
}
const f = makeTransferable(F, 1);
f instanceof F; // true
f instanceof E; // true
f instanceof JSTransferable; // false
const mc = new MessageChannel();
mc.port1.onmessage = ({ data }) => {
data instanceof F; // true
data instanceof E; // true
data instanceof JSTransferable; // false
};
mc.port2.postMessage(f); // works!
```
The additional `internal/test/transfer.js` file is required for the
test because successfully deserializing transferable classes requires
that they be located in `lib/internal` for now.
Signed-off-by: James M Snell <jasnell@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/38383
Reviewed-By: Anna Henningsen <anna@addaleax.net>
Reviewed-By: Khaidi Chu <i@2333.moe>
57 lines
1.7 KiB
JavaScript
57 lines
1.7 KiB
JavaScript
'use strict';
|
|
const {
|
|
Error,
|
|
ObjectDefineProperties,
|
|
ObjectGetOwnPropertyDescriptors,
|
|
ObjectGetPrototypeOf,
|
|
ObjectSetPrototypeOf,
|
|
ReflectConstruct,
|
|
StringPrototypeSplit,
|
|
} = primordials;
|
|
const {
|
|
messaging_deserialize_symbol,
|
|
messaging_transfer_symbol,
|
|
messaging_clone_symbol,
|
|
messaging_transfer_list_symbol
|
|
} = internalBinding('symbols');
|
|
const {
|
|
JSTransferable,
|
|
setDeserializerCreateObjectFunction
|
|
} = internalBinding('messaging');
|
|
|
|
function setup() {
|
|
// Register the handler that will be used when deserializing JS-based objects
|
|
// from .postMessage() calls. The format of `deserializeInfo` is generally
|
|
// 'module:Constructor', e.g. 'internal/fs/promises:FileHandle'.
|
|
setDeserializerCreateObjectFunction((deserializeInfo) => {
|
|
const { 0: module, 1: ctor } = StringPrototypeSplit(deserializeInfo, ':');
|
|
const Ctor = require(module)[ctor];
|
|
if (typeof Ctor !== 'function' ||
|
|
typeof Ctor.prototype[messaging_deserialize_symbol] !== 'function') {
|
|
// Not one of the official errors because one should not be able to get
|
|
// here without messing with Node.js internals.
|
|
// eslint-disable-next-line no-restricted-syntax
|
|
throw new Error(`Unknown deserialize spec ${deserializeInfo}`);
|
|
}
|
|
|
|
return new Ctor();
|
|
});
|
|
}
|
|
|
|
function makeTransferable(obj) {
|
|
const inst = ReflectConstruct(JSTransferable, [], obj.constructor);
|
|
ObjectDefineProperties(inst, ObjectGetOwnPropertyDescriptors(obj));
|
|
ObjectSetPrototypeOf(inst, ObjectGetPrototypeOf(obj));
|
|
return inst;
|
|
}
|
|
|
|
module.exports = {
|
|
makeTransferable,
|
|
setup,
|
|
JSTransferable,
|
|
kClone: messaging_clone_symbol,
|
|
kDeserialize: messaging_deserialize_symbol,
|
|
kTransfer: messaging_transfer_symbol,
|
|
kTransferList: messaging_transfer_list_symbol,
|
|
};
|