├── .gitignore ├── .travis.yml ├── CODEOWNERS ├── CONTRIBUTING ├── CONTRIBUTORS ├── Dockerfile ├── LICENSE ├── README.md ├── dist ├── bundle │ └── clooney.js ├── clooney.d.ts └── clooney.js ├── examples └── index.html ├── karma.conf.js ├── licenseheader.txt ├── package-lock.json ├── package.json ├── renovate.json ├── rollup.config.js ├── src └── clooney.ts ├── tests ├── fixtures │ └── worker.js └── sometests.js └── tsconfig.json /.gitignore: -------------------------------------------------------------------------------- 1 | node_modules 2 | dist/package.json 3 | dist/README.md 4 | *.pem 5 | *.bak 6 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: required 2 | 3 | services: 4 | - docker 5 | 6 | script: 7 | - docker build -t clooney . 8 | - docker run --rm -v `pwd`:/usr/src clooney 9 | -------------------------------------------------------------------------------- /CODEOWNERS: -------------------------------------------------------------------------------- 1 | @surma 2 | -------------------------------------------------------------------------------- /CONTRIBUTING: -------------------------------------------------------------------------------- 1 | Want to contribute? Great! First, read this page (including the small print at the end). 2 | 3 | ### Before you contribute 4 | Before we can use your code, you must sign the 5 | [Google Individual Contributor License Agreement] 6 | (https://cla.developers.google.com/about/google-individual) 7 | (CLA), which you can do online. The CLA is necessary mainly because you own the 8 | copyright to your changes, even after your contribution becomes part of our 9 | codebase, so we need your permission to use and distribute your code. We also 10 | need to be sure of various other things—for instance that you'll tell us if you 11 | know that your code infringes on other people's patents. You don't have to sign 12 | the CLA until after you've submitted your code for review and a member has 13 | approved it, but you must do it before we can put your code into our codebase. 14 | Before you start working on a larger contribution, you should get in touch with 15 | us first through the issue tracker with your idea so that we can help out and 16 | possibly guide you. Coordinating up front makes it much easier to avoid 17 | frustration later on. 18 | 19 | ### Code reviews 20 | All submissions, including submissions by project members, require review. We 21 | use Github pull requests for this purpose. 22 | 23 | ### The small print 24 | Contributions made by corporations are covered by a different agreement than 25 | the one above, the 26 | [Software Grant and Corporate Contributor License Agreement] 27 | (https://cla.developers.google.com/about/google-corporate). 28 | -------------------------------------------------------------------------------- /CONTRIBUTORS: -------------------------------------------------------------------------------- 1 | # People who have agreed to one of the CLAs and can contribute patches. 2 | # The AUTHORS file lists the copyright holders; this file 3 | # lists people. For example, Google employees are listed here 4 | # but not in AUTHORS, because Google holds the copyright. 5 | # 6 | # https://developers.google.com/open-source/cla/individual 7 | # https://developers.google.com/open-source/cla/corporate 8 | # 9 | # Names should be added to this file as: 10 | # Name 11 | Surma 12 | -------------------------------------------------------------------------------- /Dockerfile: -------------------------------------------------------------------------------- 1 | FROM selenium/node-chrome:latest@sha256:498f1c5c5c3d2c4fbd05981a187c7df3385cef68caa72002ed3b5a587f4a2577 2 | 3 | USER root 4 | 5 | RUN apt-get update -qqy \ 6 | && rm -rf /var/lib/apt/lists/* /var/cache/apt/* \ 7 | && rm /bin/sh && ln -s /bin/bash /bin/sh \ 8 | && chown seluser /usr/local 9 | 10 | ENV NVM_DIR /usr/local/nvm 11 | RUN wget -qO- https://raw.githubusercontent.com/creationix/nvm/v0.33.2/install.sh | bash \ 12 | && source $NVM_DIR/nvm.sh \ 13 | && nvm install v8 14 | 15 | ENV CHROME_BIN /opt/google/chrome/chrome 16 | ENV INSIDE_DOCKER=1 17 | 18 | WORKDIR /usr/src 19 | ENTRYPOINT source $NVM_DIR/nvm.sh && npm i && npm test 20 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | 2 | Apache License 3 | Version 2.0, January 2004 4 | http://www.apache.org/licenses/ 5 | 6 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 7 | 8 | 1. Definitions. 9 | 10 | "License" shall mean the terms and conditions for use, reproduction, 11 | and distribution as defined by Sections 1 through 9 of this document. 12 | 13 | "Licensor" shall mean the copyright owner or entity authorized by 14 | the copyright owner that is granting the License. 15 | 16 | "Legal Entity" shall mean the union of the acting entity and all 17 | other entities that control, are controlled by, or are under common 18 | control with that entity. For the purposes of this definition, 19 | "control" means (i) the power, direct or indirect, to cause the 20 | direction or management of such entity, whether by contract or 21 | otherwise, or (ii) ownership of fifty percent (50%) or more of the 22 | outstanding shares, or (iii) beneficial ownership of such entity. 23 | 24 | "You" (or "Your") shall mean an individual or Legal Entity 25 | exercising permissions granted by this License. 26 | 27 | "Source" form shall mean the preferred form for making modifications, 28 | including but not limited to software source code, documentation 29 | source, and configuration files. 30 | 31 | "Object" form shall mean any form resulting from mechanical 32 | transformation or translation of a Source form, including but 33 | not limited to compiled object code, generated documentation, 34 | and conversions to other media types. 35 | 36 | "Work" shall mean the work of authorship, whether in Source or 37 | Object form, made available under the License, as indicated by a 38 | copyright notice that is included in or attached to the work 39 | (an example is provided in the Appendix below). 40 | 41 | "Derivative Works" shall mean any work, whether in Source or Object 42 | form, that is based on (or derived from) the Work and for which the 43 | editorial revisions, annotations, elaborations, or other modifications 44 | represent, as a whole, an original work of authorship. For the purposes 45 | of this License, Derivative Works shall not include works that remain 46 | separable from, or merely link (or bind by name) to the interfaces of, 47 | the Work and Derivative Works thereof. 48 | 49 | "Contribution" shall mean any work of authorship, including 50 | the original version of the Work and any modifications or additions 51 | to that Work or Derivative Works thereof, that is intentionally 52 | submitted to Licensor for inclusion in the Work by the copyright owner 53 | or by an individual or Legal Entity authorized to submit on behalf of 54 | the copyright owner. For the purposes of this definition, "submitted" 55 | means any form of electronic, verbal, or written communication sent 56 | to the Licensor or its representatives, including but not limited to 57 | communication on electronic mailing lists, source code control systems, 58 | and issue tracking systems that are managed by, or on behalf of, the 59 | Licensor for the purpose of discussing and improving the Work, but 60 | excluding communication that is conspicuously marked or otherwise 61 | designated in writing by the copyright owner as "Not a Contribution." 62 | 63 | "Contributor" shall mean Licensor and any individual or Legal Entity 64 | on behalf of whom a Contribution has been received by Licensor and 65 | subsequently incorporated within the Work. 66 | 67 | 2. Grant of Copyright License. Subject to the terms and conditions of 68 | this License, each Contributor hereby grants to You a perpetual, 69 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 70 | copyright license to reproduce, prepare Derivative Works of, 71 | publicly display, publicly perform, sublicense, and distribute the 72 | Work and such Derivative Works in Source or Object form. 73 | 74 | 3. Grant of Patent License. Subject to the terms and conditions of 75 | this License, each Contributor hereby grants to You a perpetual, 76 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 77 | (except as stated in this section) patent license to make, have made, 78 | use, offer to sell, sell, import, and otherwise transfer the Work, 79 | where such license applies only to those patent claims licensable 80 | by such Contributor that are necessarily infringed by their 81 | Contribution(s) alone or by combination of their Contribution(s) 82 | with the Work to which such Contribution(s) was submitted. If You 83 | institute patent litigation against any entity (including a 84 | cross-claim or counterclaim in a lawsuit) alleging that the Work 85 | or a Contribution incorporated within the Work constitutes direct 86 | or contributory patent infringement, then any patent licenses 87 | granted to You under this License for that Work shall terminate 88 | as of the date such litigation is filed. 89 | 90 | 4. Redistribution. You may reproduce and distribute copies of the 91 | Work or Derivative Works thereof in any medium, with or without 92 | modifications, and in Source or Object form, provided that You 93 | meet the following conditions: 94 | 95 | (a) You must give any other recipients of the Work or 96 | Derivative Works a copy of this License; and 97 | 98 | (b) You must cause any modified files to carry prominent notices 99 | stating that You changed the files; and 100 | 101 | (c) You must retain, in the Source form of any Derivative Works 102 | that You distribute, all copyright, patent, trademark, and 103 | attribution notices from the Source form of the Work, 104 | excluding those notices that do not pertain to any part of 105 | the Derivative Works; and 106 | 107 | (d) If the Work includes a "NOTICE" text file as part of its 108 | distribution, then any Derivative Works that You distribute must 109 | include a readable copy of the attribution notices contained 110 | within such NOTICE file, excluding those notices that do not 111 | pertain to any part of the Derivative Works, in at least one 112 | of the following places: within a NOTICE text file distributed 113 | as part of the Derivative Works; within the Source form or 114 | documentation, if provided along with the Derivative Works; or, 115 | within a display generated by the Derivative Works, if and 116 | wherever such third-party notices normally appear. The contents 117 | of the NOTICE file are for informational purposes only and 118 | do not modify the License. You may add Your own attribution 119 | notices within Derivative Works that You distribute, alongside 120 | or as an addendum to the NOTICE text from the Work, provided 121 | that such additional attribution notices cannot be construed 122 | as modifying the License. 123 | 124 | You may add Your own copyright statement to Your modifications and 125 | may provide additional or different license terms and conditions 126 | for use, reproduction, or distribution of Your modifications, or 127 | for any such Derivative Works as a whole, provided Your use, 128 | reproduction, and distribution of the Work otherwise complies with 129 | the conditions stated in this License. 130 | 131 | 5. Submission of Contributions. Unless You explicitly state otherwise, 132 | any Contribution intentionally submitted for inclusion in the Work 133 | by You to the Licensor shall be under the terms and conditions of 134 | this License, without any additional terms or conditions. 135 | Notwithstanding the above, nothing herein shall supersede or modify 136 | the terms of any separate license agreement you may have executed 137 | with Licensor regarding such Contributions. 138 | 139 | 6. Trademarks. This License does not grant permission to use the trade 140 | names, trademarks, service marks, or product names of the Licensor, 141 | except as required for reasonable and customary use in describing the 142 | origin of the Work and reproducing the content of the NOTICE file. 143 | 144 | 7. Disclaimer of Warranty. Unless required by applicable law or 145 | agreed to in writing, Licensor provides the Work (and each 146 | Contributor provides its Contributions) on an "AS IS" BASIS, 147 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 148 | implied, including, without limitation, any warranties or conditions 149 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A 150 | PARTICULAR PURPOSE. You are solely responsible for determining the 151 | appropriateness of using or redistributing the Work and assume any 152 | risks associated with Your exercise of permissions under this License. 153 | 154 | 8. Limitation of Liability. In no event and under no legal theory, 155 | whether in tort (including negligence), contract, or otherwise, 156 | unless required by applicable law (such as deliberate and grossly 157 | negligent acts) or agreed to in writing, shall any Contributor be 158 | liable to You for damages, including any direct, indirect, special, 159 | incidental, or consequential damages of any character arising as a 160 | result of this License or out of the use or inability to use the 161 | Work (including but not limited to damages for loss of goodwill, 162 | work stoppage, computer failure or malfunction, or any and all 163 | other commercial damages or losses), even if such Contributor 164 | has been advised of the possibility of such damages. 165 | 166 | 9. Accepting Warranty or Additional Liability. While redistributing 167 | the Work or Derivative Works thereof, You may choose to offer, 168 | and charge a fee for, acceptance of support, warranty, indemnity, 169 | or other liability obligations and/or rights consistent with this 170 | License. However, in accepting such obligations, You may act only 171 | on Your own behalf and on Your sole responsibility, not on behalf 172 | of any other Contributor, and only if You agree to indemnify, 173 | defend, and hold each Contributor harmless for any liability 174 | incurred by, or claims asserted against, such Contributor by reason 175 | of your accepting any such warranty or additional liability. 176 | 177 | END OF TERMS AND CONDITIONS 178 | 179 | APPENDIX: How to apply the Apache License to your work. 180 | 181 | To apply the Apache License to your work, attach the following 182 | boilerplate notice, with the fields enclosed by brackets "[]" 183 | replaced with your own identifying information. (Don't include 184 | the brackets!) The text should be enclosed in the appropriate 185 | comment syntax for the file format. We also recommend that a 186 | file or class name and description of purpose be included on the 187 | same "printed page" as the copyright notice for easier 188 | identification within third-party archives. 189 | 190 | Copyright 2018 Google Inc. 191 | 192 | Licensed under the Apache License, Version 2.0 (the "License"); 193 | you may not use this file except in compliance with the License. 194 | You may obtain a copy of the License at 195 | 196 | http://www.apache.org/licenses/LICENSE-2.0 197 | 198 | Unless required by applicable law or agreed to in writing, software 199 | distributed under the License is distributed on an "AS IS" BASIS, 200 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 201 | See the License for the specific language governing permissions and 202 | limitations under the License. 203 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Clooney 2 | Clooney is an actor (ayooo) library for the web. Classes given to Clooney will be instantiated and run in a worker, keeping the main thread responsive. 3 | 4 | > ⚠️ **Caveat:** The class cannot rely on its surrounding scope, since it is executed in an isolated context. This might change once workers support ES6 modules. 5 | 6 | ## Quickstart 7 | An example says more than 1000 words: 8 | 9 | ```html 10 | 11 | 23 | ``` 24 | 25 | I’m collecting more examples of Clooney in action in [this Glitch](https://clooney-examples.glitch.me/). 26 | 27 | ## Browser support 28 | 29 | Clooney uses [Comlink] under the hood, and so inherits its browser compatibility matrix. 30 | 31 | ![Chrome 56+](https://img.shields.io/badge/Chrome-56+-green.svg?style=flat-square) 32 | ![Edge 15+](https://img.shields.io/badge/Edge-15+-green.svg?style=flat-square) 33 | ![Firefox 52+](https://img.shields.io/badge/Firefox-52+-green.svg?style=flat-square) 34 | ![Opera 43+](https://img.shields.io/badge/Opera-43+-green.svg?style=flat-square) 35 | ![Safari 10.1+](https://img.shields.io/badge/Safari-10.1+-green.svg?style=flat-square) 36 | ![Samsung Internet 6.0+](https://img.shields.io/badge/Samsung_Internet-6.0+-green.svg?style=flat-square) 37 | 38 | Browsers without [ES6 Proxy] support can use the [proxy-polyfill]. 39 | 40 | ## Events and Functions 41 | Functions and events are not transferable (i.e. can’t be sent from to a worker), but Clooney has special handling for them: 42 | 43 | ```js 44 | class MyRemoteClass { 45 | onClick(remoteEvent) { 46 | // … react to click … 47 | } 48 | } 49 | 50 | const instance = await Clooney.spawn(MyRemoteClass); 51 | const button = document.querySelector('button'); 52 | button.addEventListener('click', instance.onClick.bind(instance)); 53 | ``` 54 | 55 | The `remoteEvent` object is a mangled version of the original event to make it transferable: 56 | 57 | ```js 58 | const remoteEvent = { 59 | targetId, // = event.target.id 60 | targetClassList, // = [...event.target.classList] 61 | detail, // = event.detail 62 | data // = event.data 63 | }; 64 | ``` 65 | 66 | ## Promises and async methods 67 | Clooney handles promises (and therefore, async methods) automatically: 68 | 69 | ```js 70 | class Actor { 71 | timeoutThing() { 72 | return new Promise(resolve => setTimeout(_ => resolve('ohai'), 1000)); 73 | } 74 | } 75 | 76 | const instance = await strategy.spawn(Actor); 77 | alert(await instance.timeoutThing()); // Will alert() after 1 second 78 | ``` 79 | 80 | ## API 81 | Clooney’s job is to take _actors_ (class definitions) and _spawn_ those actors in _containers_ ([Web Workers][Web Worker]). You can use that instance as if it was a local instance (this is magic provided by [Comlink]). 82 | 83 | ### `Clooney.spawn(class, constructorArgs)` 84 | This call is equivalent to `Clooney.defaultStrategy.spawn(class, constructorArgs)`. Clooney creates an instance of `RoundRobinStrategy` as the default strategy. 85 | 86 | ### Strategies 87 | Strategies decide how many containers are spun up and where a new instance is created. 88 | 89 | ```typescript 90 | export interface Strategy { 91 | /** 92 | * `spawn` instantiates the given actor in an actor container of the strategy’s choice. 93 | * @returns The return type is the type as T, but every method is implicitly async. 94 | */ 95 | spawn(actor: new () => T, constructorArgs: any[], opts: Object): Promise; 96 | /** 97 | * `terminate` calls `terminate()` on all existing containers of the strategy. 98 | */ 99 | terminate(): Promise; 100 | } 101 | ``` 102 | 103 | #### `Clooney.RoundRobinStrategy(opts)` 104 | `RoundRobinStrategy` creates up to n containers and cycles through the containers with every `spawn` call. `RoundRobinStrategy` is the default strategy. 105 | 106 | ### Strategy Options 107 | 108 | - `maxNumContainers`: Maximum number of containers to create (default: 1) 109 | - `newWorkerFunc`: Asynchronous function that creates a new container (default: `new Worker(Clooney.defaultWorkerSrc)`) 110 | 111 | ### `Clooney.asRemoteValue(obj)` 112 | 113 | `asRemoteValue` marks a value. If a marked value is used as an parameter or return value, it will not be transferred but instead proxied. 114 | 115 | ## CDN 116 | If you want to use Clooney from a CDN, you need to work around the same-origin restrictions that workers have: 117 | 118 | ```html 119 | 120 | 129 | ``` 130 | 131 | [Comlink]: https://github.com/GoogleChromeLabs/comlink 132 | [Web Worker]: https://developer.mozilla.org/en-US/docs/Web/API/Web_Workers_API 133 | [es6 proxy]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy 134 | [proxy-polyfill]: https://github.com/GoogleChrome/proxy-polyfill 135 | 136 | --- 137 | License Apache-2.0 138 | -------------------------------------------------------------------------------- /dist/bundle/clooney.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @license 3 | * Copyright 2018 Google Inc. All Rights Reserved. 4 | * Licensed under the Apache License, Version 2.0 (the "License"); 5 | * you may not use this file except in compliance with the License. 6 | * You may obtain a copy of the License at 7 | * http://www.apache.org/licenses/LICENSE-2.0 8 | * Unless required by applicable law or agreed to in writing, software 9 | * distributed under the License is distributed on an "AS IS" BASIS, 10 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 11 | * See the License for the specific language governing permissions and 12 | * limitations under the License. 13 | */ 14 | 15 | var Clooney = (function (exports) { 16 | 'use strict'; 17 | 18 | /** 19 | * Copyright 2017 Google Inc. All Rights Reserved. 20 | * Licensed under the Apache License, Version 2.0 (the "License"); 21 | * you may not use this file except in compliance with the License. 22 | * You may obtain a copy of the License at 23 | * http://www.apache.org/licenses/LICENSE-2.0 24 | * Unless required by applicable law or agreed to in writing, software 25 | * distributed under the License is distributed on an "AS IS" BASIS, 26 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 27 | * See the License for the specific language governing permissions and 28 | * limitations under the License. 29 | */ 30 | const TRANSFERABLE_TYPES = [ArrayBuffer, MessagePort]; 31 | const uid = Math.floor(Math.random() * Number.MAX_SAFE_INTEGER); 32 | const proxyValueSymbol = Symbol("proxyValue"); 33 | const throwSymbol = Symbol("throw"); 34 | const proxyTransferHandler = { 35 | canHandle: (obj) => obj && obj[proxyValueSymbol], 36 | serialize: (obj) => { 37 | const { port1, port2 } = new MessageChannel(); 38 | expose(obj, port1); 39 | return port2; 40 | }, 41 | deserialize: (obj) => { 42 | return proxy(obj); 43 | } 44 | }; 45 | const throwTransferHandler = { 46 | canHandle: (obj) => obj && obj[throwSymbol], 47 | serialize: (obj) => obj.toString() + "\n" + obj.stack, 48 | deserialize: (obj) => { 49 | throw Error(obj); 50 | } 51 | }; 52 | const transferHandlers = new Map([ 53 | ["PROXY", proxyTransferHandler], 54 | ["THROW", throwTransferHandler] 55 | ]); 56 | let pingPongMessageCounter = 0; 57 | function proxy(endpoint, target) { 58 | if (isWindow(endpoint)) 59 | endpoint = windowEndpoint(endpoint); 60 | if (!isEndpoint(endpoint)) 61 | throw Error("endpoint does not have all of addEventListener, removeEventListener and postMessage defined"); 62 | activateEndpoint(endpoint); 63 | return cbProxy(async (irequest) => { 64 | let args = []; 65 | if (irequest.type === "APPLY" || irequest.type === "CONSTRUCT") 66 | args = irequest.argumentsList.map(wrapValue); 67 | const response = await pingPongMessage(endpoint, Object.assign({}, irequest, { argumentsList: args }), transferableProperties(args)); 68 | const result = response.data; 69 | return unwrapValue(result.value); 70 | }, [], target); 71 | } 72 | function proxyValue(obj) { 73 | obj[proxyValueSymbol] = true; 74 | return obj; 75 | } 76 | function expose(rootObj, endpoint) { 77 | if (isWindow(endpoint)) 78 | endpoint = windowEndpoint(endpoint); 79 | if (!isEndpoint(endpoint)) 80 | throw Error("endpoint does not have all of addEventListener, removeEventListener and postMessage defined"); 81 | activateEndpoint(endpoint); 82 | attachMessageHandler(endpoint, async function (event) { 83 | if (!event.data.id || !event.data.callPath) 84 | return; 85 | const irequest = event.data; 86 | let that = await irequest.callPath 87 | .slice(0, -1) 88 | .reduce((obj, propName) => obj[propName], rootObj); 89 | let obj = await irequest.callPath.reduce((obj, propName) => obj[propName], rootObj); 90 | let iresult = obj; 91 | let args = []; 92 | if (irequest.type === "APPLY" || irequest.type === "CONSTRUCT") 93 | args = irequest.argumentsList.map(unwrapValue); 94 | if (irequest.type === "APPLY") { 95 | try { 96 | iresult = await obj.apply(that, args); 97 | } 98 | catch (e) { 99 | iresult = e; 100 | iresult[throwSymbol] = true; 101 | } 102 | } 103 | if (irequest.type === "CONSTRUCT") { 104 | try { 105 | iresult = new obj(...args); // eslint-disable-line new-cap 106 | iresult = proxyValue(iresult); 107 | } 108 | catch (e) { 109 | iresult = e; 110 | iresult[throwSymbol] = true; 111 | } 112 | } 113 | if (irequest.type === "SET") { 114 | obj[irequest.property] = irequest.value; 115 | // FIXME: ES6 Proxy Handler `set` methods are supposed to return a 116 | // boolean. To show good will, we return true asynchronously ¯\_(ツ)_/¯ 117 | iresult = true; 118 | } 119 | iresult = makeInvocationResult(iresult); 120 | iresult.id = irequest.id; 121 | return endpoint.postMessage(iresult, transferableProperties([iresult])); 122 | }); 123 | } 124 | function wrapValue(arg) { 125 | // Is arg itself handled by a TransferHandler? 126 | for (const [key, transferHandler] of transferHandlers) { 127 | if (transferHandler.canHandle(arg)) { 128 | return { 129 | type: key, 130 | value: transferHandler.serialize(arg) 131 | }; 132 | } 133 | } 134 | // If not, traverse the entire object and find handled values. 135 | let wrappedChildren = []; 136 | for (const item of iterateAllProperties(arg)) { 137 | for (const [key, transferHandler] of transferHandlers) { 138 | if (transferHandler.canHandle(item.value)) { 139 | wrappedChildren.push({ 140 | path: item.path, 141 | wrappedValue: { 142 | type: key, 143 | value: transferHandler.serialize(item.value) 144 | } 145 | }); 146 | } 147 | } 148 | } 149 | for (const wrappedChild of wrappedChildren) { 150 | const container = wrappedChild.path 151 | .slice(0, -1) 152 | .reduce((obj, key) => obj[key], arg); 153 | container[wrappedChild.path[wrappedChild.path.length - 1]] = null; 154 | } 155 | return { 156 | type: "RAW", 157 | value: arg, 158 | wrappedChildren 159 | }; 160 | } 161 | function unwrapValue(arg) { 162 | if (transferHandlers.has(arg.type)) { 163 | const transferHandler = transferHandlers.get(arg.type); 164 | return transferHandler.deserialize(arg.value); 165 | } 166 | else if (isRawWrappedValue(arg)) { 167 | for (const wrappedChildValue of arg.wrappedChildren || []) { 168 | if (!transferHandlers.has(wrappedChildValue.wrappedValue.type)) 169 | throw Error(`Unknown value type "${arg.type}" at ${wrappedChildValue.path.join(".")}`); 170 | const transferHandler = transferHandlers.get(wrappedChildValue.wrappedValue.type); 171 | const newValue = transferHandler.deserialize(wrappedChildValue.wrappedValue.value); 172 | replaceValueInObjectAtPath(arg.value, wrappedChildValue.path, newValue); 173 | } 174 | return arg.value; 175 | } 176 | else { 177 | throw Error(`Unknown value type "${arg.type}"`); 178 | } 179 | } 180 | function replaceValueInObjectAtPath(obj, path, newVal) { 181 | const lastKey = path.slice(-1)[0]; 182 | const lastObj = path 183 | .slice(0, -1) 184 | .reduce((obj, key) => obj[key], obj); 185 | lastObj[lastKey] = newVal; 186 | } 187 | function isRawWrappedValue(arg) { 188 | return arg.type === "RAW"; 189 | } 190 | function windowEndpoint(w) { 191 | if (self.constructor.name !== "Window") 192 | throw Error("self is not a window"); 193 | return { 194 | addEventListener: self.addEventListener.bind(self), 195 | removeEventListener: self.removeEventListener.bind(self), 196 | postMessage: (msg, transfer) => w.postMessage(msg, "*", transfer) 197 | }; 198 | } 199 | function isEndpoint(endpoint) { 200 | return ("addEventListener" in endpoint && 201 | "removeEventListener" in endpoint && 202 | "postMessage" in endpoint); 203 | } 204 | function activateEndpoint(endpoint) { 205 | if (isMessagePort(endpoint)) 206 | endpoint.start(); 207 | } 208 | function attachMessageHandler(endpoint, f) { 209 | // Checking all possible types of `endpoint` manually satisfies TypeScript’s 210 | // type checker. Not sure why the inference is failing here. Since it’s 211 | // unnecessary code I’m going to resort to `any` for now. 212 | // if(isWorker(endpoint)) 213 | // endpoint.addEventListener('message', f); 214 | // if(isMessagePort(endpoint)) 215 | // endpoint.addEventListener('message', f); 216 | // if(isOtherWindow(endpoint)) 217 | // endpoint.addEventListener('message', f); 218 | endpoint.addEventListener("message", f); 219 | } 220 | function detachMessageHandler(endpoint, f) { 221 | // Same as above. 222 | endpoint.removeEventListener("message", f); 223 | } 224 | function isMessagePort(endpoint) { 225 | return endpoint.constructor.name === "MessagePort"; 226 | } 227 | function isWindow(endpoint) { 228 | // TODO: This doesn’t work on cross-origin iframes. 229 | // return endpoint.constructor.name === 'Window'; 230 | return ["window", "length", "location", "parent", "opener"].every(prop => prop in endpoint); 231 | } 232 | /** 233 | * `pingPongMessage` sends a `postMessage` and waits for a reply. Replies are 234 | * identified by a unique id that is attached to the payload. 235 | */ 236 | function pingPongMessage(endpoint, msg, transferables) { 237 | const id = `${uid}-${pingPongMessageCounter++}`; 238 | return new Promise(resolve => { 239 | attachMessageHandler(endpoint, function handler(event) { 240 | if (event.data.id !== id) 241 | return; 242 | detachMessageHandler(endpoint, handler); 243 | resolve(event); 244 | }); 245 | // Copy msg and add `id` property 246 | msg = Object.assign({}, msg, { id }); 247 | endpoint.postMessage(msg, transferables); 248 | }); 249 | } 250 | function cbProxy(cb, callPath = [], target = function () { }) { 251 | return new Proxy(target, { 252 | construct(_target, argumentsList, proxy) { 253 | return cb({ 254 | type: "CONSTRUCT", 255 | callPath, 256 | argumentsList 257 | }); 258 | }, 259 | apply(_target, _thisArg, argumentsList) { 260 | // We use `bind` as an indicator to have a remote function bound locally. 261 | // The actual target for `bind()` is currently ignored. 262 | if (callPath[callPath.length - 1] === "bind") 263 | return cbProxy(cb, callPath.slice(0, -1)); 264 | return cb({ 265 | type: "APPLY", 266 | callPath, 267 | argumentsList 268 | }); 269 | }, 270 | get(_target, property, proxy) { 271 | if (property === "then" && callPath.length === 0) { 272 | return { then: () => proxy }; 273 | } 274 | else if (property === "then") { 275 | const r = cb({ 276 | type: "GET", 277 | callPath 278 | }); 279 | return Promise.resolve(r).then.bind(r); 280 | } 281 | else { 282 | return cbProxy(cb, callPath.concat(property), _target[property]); 283 | } 284 | }, 285 | set(_target, property, value, _proxy) { 286 | return cb({ 287 | type: "SET", 288 | callPath, 289 | property, 290 | value 291 | }); 292 | } 293 | }); 294 | } 295 | function isTransferable(thing) { 296 | return TRANSFERABLE_TYPES.some(type => thing instanceof type); 297 | } 298 | function* iterateAllProperties(value, path = [], visited = null) { 299 | if (!value) 300 | return; 301 | if (!visited) 302 | visited = new WeakSet(); 303 | if (visited.has(value)) 304 | return; 305 | if (typeof value === "string") 306 | return; 307 | if (typeof value === "object") 308 | visited.add(value); 309 | if (ArrayBuffer.isView(value)) 310 | return; 311 | yield { value, path }; 312 | const keys = Object.keys(value); 313 | for (const key of keys) 314 | yield* iterateAllProperties(value[key], [...path, key], visited); 315 | } 316 | function transferableProperties(obj) { 317 | const r = []; 318 | for (const prop of iterateAllProperties(obj)) { 319 | if (isTransferable(prop.value)) 320 | r.push(prop.value); 321 | } 322 | return r; 323 | } 324 | function makeInvocationResult(obj) { 325 | for (const [type, transferHandler] of transferHandlers) { 326 | if (transferHandler.canHandle(obj)) { 327 | const value = transferHandler.serialize(obj); 328 | return { 329 | value: { type, value } 330 | }; 331 | } 332 | } 333 | return { 334 | value: { 335 | type: "RAW", 336 | value: obj 337 | } 338 | }; 339 | } 340 | 341 | var comlink = /*#__PURE__*/Object.freeze({ 342 | transferHandlers: transferHandlers, 343 | proxy: proxy, 344 | proxyValue: proxyValue, 345 | expose: expose 346 | }); 347 | 348 | /** 349 | * Copyright 2018 Google Inc. All Rights Reserved. 350 | * Licensed under the Apache License, Version 2.0 (the "License"); 351 | * you may not use this file except in compliance with the License. 352 | * You may obtain a copy of the License at 353 | * http://www.apache.org/licenses/LICENSE-2.0 354 | * Unless required by applicable law or agreed to in writing, software 355 | * distributed under the License is distributed on an "AS IS" BASIS, 356 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 357 | * See the License for the specific language governing permissions and 358 | * limitations under the License. 359 | */ 360 | // Automatically proxy functions 361 | transferHandlers.set("FUNCTION", { 362 | canHandle(obj) { 363 | return obj instanceof Function; 364 | }, 365 | serialize(obj) { 366 | const { port1, port2 } = new MessageChannel(); 367 | expose(obj, port1); 368 | return port2; 369 | }, 370 | deserialize(obj) { 371 | return proxy(obj); 372 | } 373 | }); 374 | // Automatically proxy events 375 | transferHandlers.set("EVENT", { 376 | canHandle(obj) { 377 | return obj instanceof Event; 378 | }, 379 | serialize(obj) { 380 | return { 381 | targetId: obj && obj.target && obj.target.id, 382 | targetClassList: obj && 383 | obj.target && 384 | obj.target.classList && [...obj.target.classList], 385 | detail: obj && obj.detail, 386 | data: obj && obj.data 387 | }; 388 | }, 389 | deserialize(obj) { 390 | return obj; 391 | } 392 | }); 393 | /** 394 | * `asRemoteValue` marks a value. If a marked value is used as an parameter or return value, it will not be transferred but instead proxied. 395 | */ 396 | const asRemoteValue = proxyValue; 397 | /** 398 | * `defaultWorkerSrc` is the path passed to the `new Worker()` call. It’s recommended to not change this variable but instead overload `newWorkerFunc`. 399 | */ 400 | let defaultWorkerSrc = "document" in self 401 | ? document.currentScript && 402 | document.currentScript.src 403 | : ""; 404 | const defaultOpts = { 405 | maxNumContainers: 1, 406 | newWorkerFunc: async () => new Worker(defaultWorkerSrc) 407 | }; 408 | /** 409 | * `RoundRobingStrategy` creates up to n containers and cycles through the containers with every `spawn` call. 410 | */ 411 | class RoundRobinStrategy { 412 | constructor(opts = {}) { 413 | this._nextIndex = 0; 414 | this._options = Object.assign({}, defaultOpts, opts); 415 | this._containers = new Array(this._options.maxNumContainers).fill(null); 416 | } 417 | async _initOrGetContainer(i) { 418 | if (i >= this._containers.length) 419 | throw Error("No worker available"); 420 | if (!this._containers[i]) { 421 | const worker = await this._options.newWorkerFunc(); 422 | const remote = proxy(worker); 423 | this._containers[i] = { 424 | spawn: remote.spawn.bind(spawn), 425 | terminate: worker.terminate.bind(worker) 426 | }; 427 | } 428 | return this._containers[i]; 429 | } 430 | async _getNextContainer(opts) { 431 | const w = await this._initOrGetContainer(this._nextIndex); 432 | this._nextIndex = (this._nextIndex + 1) % this._options.maxNumContainers; 433 | return w; 434 | } 435 | async spawn(actor, constructorArgs = [], opts = {}) { 436 | const container = await this._getNextContainer(opts); 437 | return (await container.spawn(actor.toString(), constructorArgs)); 438 | } 439 | async terminate() { 440 | this._containers.filter(c => c).forEach(container => container.terminate()); 441 | this._containers.length = 0; 442 | } 443 | get terminated() { 444 | return this._containers.length <= 0; 445 | } 446 | } 447 | let defaultStrategy = new RoundRobinStrategy(); 448 | async function spawn(actor, constructorArgs = [], opts = {}) { 449 | return defaultStrategy.spawn(actor, constructorArgs, opts); 450 | } 451 | function makeContainer(endpoint = self) { 452 | expose({ 453 | async spawn(actorCode, constructorArgs) { 454 | const actor = new Function(`return ${actorCode};`)(); 455 | return proxyValue(new actor(...constructorArgs)); // eslint-disable-line new-cap 456 | } 457 | }, endpoint); 458 | } 459 | function isWorker() { 460 | // I’d have to import lib.webworker.d.ts to have access to 461 | // WorkerGlobalScope, but I can’t because it conflicts with lib.dom.d.ts. 462 | const wgs = self["WorkerGlobalScope"]; 463 | return wgs && self instanceof wgs; 464 | } 465 | // TODO: Find a way to opt-out of autostart 466 | if (isWorker()) 467 | makeContainer(); 468 | 469 | exports.Comlink = comlink; 470 | exports.asRemoteValue = asRemoteValue; 471 | exports.defaultWorkerSrc = defaultWorkerSrc; 472 | exports.defaultOpts = defaultOpts; 473 | exports.RoundRobinStrategy = RoundRobinStrategy; 474 | exports.defaultStrategy = defaultStrategy; 475 | exports.spawn = spawn; 476 | exports.makeContainer = makeContainer; 477 | 478 | return exports; 479 | 480 | }({})); 481 | -------------------------------------------------------------------------------- /dist/clooney.d.ts: -------------------------------------------------------------------------------- 1 | /** 2 | * Copyright 2018 Google Inc. All Rights Reserved. 3 | * Licensed under the Apache License, Version 2.0 (the "License"); 4 | * you may not use this file except in compliance with the License. 5 | * You may obtain a copy of the License at 6 | * http://www.apache.org/licenses/LICENSE-2.0 7 | * Unless required by applicable law or agreed to in writing, software 8 | * distributed under the License is distributed on an "AS IS" BASIS, 9 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 10 | * See the License for the specific language governing permissions and 11 | * limitations under the License. 12 | */ 13 | import * as Comlink from "comlinkjs"; 14 | import { Endpoint } from "comlinkjs"; 15 | export { Comlink }; 16 | /** 17 | * `asRemoteValue` marks a value. If a marked value is used as an parameter or return value, it will not be transferred but instead proxied. 18 | */ 19 | export declare const asRemoteValue: (x: T) => T; 20 | /** 21 | * `defaultWorkerSrc` is the path passed to the `new Worker()` call. It’s recommended to not change this variable but instead overload `newWorkerFunc`. 22 | */ 23 | export declare let defaultWorkerSrc: string; 24 | export declare type Actor = Function; 25 | export declare type ActorSource = string; 26 | export interface TerminatableEndpoint extends Endpoint { 27 | terminate(): void; 28 | } 29 | /** 30 | * ActorContainer can run actors. This interface is implemented by Web Workers. 31 | */ 32 | export interface ActorContainer { 33 | spawn(actor: ActorSource, opts: Object): Promise