{"version":3,"file":"comlink.js","sources":["../../src/comlink.ts"],"sourcesContent":["/**\n * Copyright 2019 Google Inc. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *     http://www.apache.org/licenses/LICENSE-2.0\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Endpoint,\n  EventSource,\n  Message,\n  MessageType,\n  PostMessageWithOrigin,\n  WireValue,\n  WireValueType,\n} from \"./protocol\";\nexport { Endpoint };\n\nexport const proxyMarker = Symbol(\"Comlink.proxy\");\nexport const createEndpoint = Symbol(\"Comlink.endpoint\");\nexport const releaseProxy = Symbol(\"Comlink.releaseProxy\");\n\nconst throwMarker = Symbol(\"Comlink.thrown\");\n\n/**\n * Interface of values that were marked to be proxied with `comlink.proxy()`.\n * Can also be implemented by classes.\n */\nexport interface ProxyMarked {\n  [proxyMarker]: true;\n}\n\n/**\n * Takes a type and wraps it in a Promise, if it not already is one.\n * This is to avoid `Promise<Promise<T>>`.\n *\n * This is the inverse of `Unpromisify<T>`.\n */\ntype Promisify<T> = T extends Promise<unknown> ? T : Promise<T>;\n/**\n * Takes a type that may be Promise and unwraps the Promise type.\n * If `P` is not a Promise, it returns `P`.\n *\n * This is the inverse of `Promisify<T>`.\n */\ntype Unpromisify<P> = P extends Promise<infer T> ? T : P;\n\n/**\n * Takes the raw type of a remote property and returns the type that is visible to the local thread on the proxy.\n *\n * Note: This needs to be its own type alias, otherwise it will not distribute over unions.\n * See https://www.typescriptlang.org/docs/handbook/advanced-types.html#distributive-conditional-types\n */\ntype RemoteProperty<T> =\n  // If the value is a method, comlink will proxy it automatically.\n  // Objects are only proxied if they are marked to be proxied.\n  // Otherwise, the property is converted to a Promise that resolves the cloned value.\n  T extends Function | ProxyMarked ? Remote<T> : Promisify<T>;\n\n/**\n * Takes the raw type of a property as a remote thread would see it through a proxy (e.g. when passed in as a function\n * argument) and returns the type that the local thread has to supply.\n *\n * This is the inverse of `RemoteProperty<T>`.\n *\n * Note: This needs to be its own type alias, otherwise it will not distribute over unions. See\n * https://www.typescriptlang.org/docs/handbook/advanced-types.html#distributive-conditional-types\n */\ntype LocalProperty<T> = T extends Function | ProxyMarked\n  ? Local<T>\n  : Unpromisify<T>;\n\n/**\n * Proxies `T` if it is a `ProxyMarked`, clones it otherwise (as handled by structured cloning and transfer handlers).\n */\nexport type ProxyOrClone<T> = T extends ProxyMarked ? Remote<T> : T;\n/**\n * Inverse of `ProxyOrClone<T>`.\n */\nexport type UnproxyOrClone<T> = T extends RemoteObject<ProxyMarked>\n  ? Local<T>\n  : T;\n\n/**\n * Takes the raw type of a remote object in the other thread and returns the type as it is visible to the local thread\n * when proxied with `Comlink.proxy()`.\n *\n * This does not handle call signatures, which is handled by the more general `Remote<T>` type.\n *\n * @template T The raw type of a remote object as seen in the other thread.\n */\nexport type RemoteObject<T> = { [P in keyof T]: RemoteProperty<T[P]> };\n/**\n * Takes the type of an object as a remote thread would see it through a proxy (e.g. when passed in as a function\n * argument) and returns the type that the local thread has to supply.\n *\n * This does not handle call signatures, which is handled by the more general `Local<T>` type.\n *\n * This is the inverse of `RemoteObject<T>`.\n *\n * @template T The type of a proxied object.\n */\nexport type LocalObject<T> = { [P in keyof T]: LocalProperty<T[P]> };\n\n/**\n * Additional special comlink methods available on each proxy returned by `Comlink.wrap()`.\n */\nexport interface ProxyMethods {\n  [createEndpoint]: () => Promise<MessagePort>;\n  [releaseProxy]: () => void;\n}\n\n/**\n * Takes the raw type of a remote object, function or class in the other thread and returns the type as it is visible to\n * the local thread from the proxy return value of `Comlink.wrap()` or `Comlink.proxy()`.\n */\nexport type Remote<T> =\n  // Handle properties\n  RemoteObject<T> &\n    // Handle call signature (if present)\n    (T extends (...args: infer TArguments) => infer TReturn\n      ? (\n          ...args: { [I in keyof TArguments]: UnproxyOrClone<TArguments[I]> }\n        ) => Promisify<ProxyOrClone<Unpromisify<TReturn>>>\n      : unknown) &\n    // Handle construct signature (if present)\n    // The return of construct signatures is always proxied (whether marked or not)\n    (T extends { new (...args: infer TArguments): infer TInstance }\n      ? {\n          new (\n            ...args: {\n              [I in keyof TArguments]: UnproxyOrClone<TArguments[I]>;\n            }\n          ): Promisify<Remote<TInstance>>;\n        }\n      : unknown) &\n    // Include additional special comlink methods available on the proxy.\n    ProxyMethods;\n\n/**\n * Expresses that a type can be either a sync or async.\n */\ntype MaybePromise<T> = Promise<T> | T;\n\n/**\n * Takes the raw type of a remote object, function or class as a remote thread would see it through a proxy (e.g. when\n * passed in as a function argument) and returns the type the local thread has to supply.\n *\n * This is the inverse of `Remote<T>`. It takes a `Remote<T>` and returns its original input `T`.\n */\nexport type Local<T> =\n  // Omit the special proxy methods (they don't need to be supplied, comlink adds them)\n  Omit<LocalObject<T>, keyof ProxyMethods> &\n    // Handle call signatures (if present)\n    (T extends (...args: infer TArguments) => infer TReturn\n      ? (\n          ...args: { [I in keyof TArguments]: ProxyOrClone<TArguments[I]> }\n        ) => // The raw function could either be sync or async, but is always proxied automatically\n        MaybePromise<UnproxyOrClone<Unpromisify<TReturn>>>\n      : unknown) &\n    // Handle construct signature (if present)\n    // The return of construct signatures is always proxied (whether marked or not)\n    (T extends { new (...args: infer TArguments): infer TInstance }\n      ? {\n          new (\n            ...args: {\n              [I in keyof TArguments]: ProxyOrClone<TArguments[I]>;\n            }\n          ): // The raw constructor could either be sync or async, but is always proxied automatically\n          MaybePromise<Local<Unpromisify<TInstance>>>;\n        }\n      : unknown);\n\nconst isObject = (val: unknown): val is object =>\n  (typeof val === \"object\" && val !== null) || typeof val === \"function\";\n\n/**\n * Customizes the serialization of certain values as determined by `canHandle()`.\n *\n * @template T The input type being handled by this transfer handler.\n * @template S The serialized type sent over the wire.\n */\nexport interface TransferHandler<T, S> {\n  /**\n   * Gets called for every value to determine whether this transfer handler\n   * should serialize the value, which includes checking that it is of the right\n   * type (but can perform checks beyond that as well).\n   */\n  canHandle(value: unknown): value is T;\n\n  /**\n   * Gets called with the value if `canHandle()` returned `true` to produce a\n   * value that can be sent in a message, consisting of structured-cloneable\n   * values and/or transferrable objects.\n   */\n  serialize(value: T): [S, Transferable[]];\n\n  /**\n   * Gets called to deserialize an incoming value that was serialized in the\n   * other thread with this transfer handler (known through the name it was\n   * registered under).\n   */\n  deserialize(value: S): T;\n}\n\n/**\n * Internal transfer handle to handle objects marked to proxy.\n */\nconst proxyTransferHandler: TransferHandler<object, MessagePort> = {\n  canHandle: (val): val is ProxyMarked =>\n    isObject(val) && (val as ProxyMarked)[proxyMarker],\n  serialize(obj) {\n    const { port1, port2 } = new MessageChannel();\n    expose(obj, port1);\n    return [port2, [port2]];\n  },\n  deserialize(port) {\n    port.start();\n    return wrap(port);\n  },\n};\n\ninterface ThrownValue {\n  [throwMarker]: unknown; // just needs to be present\n  value: unknown;\n}\ntype SerializedThrownValue =\n  | { isError: true; value: Error }\n  | { isError: false; value: unknown };\n\n/**\n * Internal transfer handler to handle thrown exceptions.\n */\nconst throwTransferHandler: TransferHandler<\n  ThrownValue,\n  SerializedThrownValue\n> = {\n  canHandle: (value): value is ThrownValue =>\n    isObject(value) && throwMarker in value,\n  serialize({ value }) {\n    let serialized: SerializedThrownValue;\n    if (value instanceof Error) {\n      serialized = {\n        isError: true,\n        value: {\n          message: value.message,\n          name: value.name,\n          stack: value.stack,\n        },\n      };\n    } else {\n      serialized = { isError: false, value };\n    }\n    return [serialized, []];\n  },\n  deserialize(serialized) {\n    if (serialized.isError) {\n      throw Object.assign(\n        new Error(serialized.value.message),\n        serialized.value\n      );\n    }\n    throw serialized.value;\n  },\n};\n\n/**\n * Allows customizing the serialization of certain values.\n */\nexport const transferHandlers = new Map<\n  string,\n  TransferHandler<unknown, unknown>\n>([\n  [\"proxy\", proxyTransferHandler],\n  [\"throw\", throwTransferHandler],\n]);\n\nexport function expose(obj: any, ep: Endpoint = self as any) {\n  ep.addEventListener(\"message\", function callback(ev: MessageEvent) {\n    if (!ev || !ev.data) {\n      return;\n    }\n    const { id, type, path } = {\n      path: [] as string[],\n      ...(ev.data as Message),\n    };\n    const argumentList = (ev.data.argumentList || []).map(fromWireValue);\n    let returnValue;\n    try {\n      const parent = path.slice(0, -1).reduce((obj, prop) => obj[prop], obj);\n      const rawValue = path.reduce((obj, prop) => obj[prop], obj);\n      switch (type) {\n        case MessageType.GET:\n          {\n            returnValue = rawValue;\n          }\n          break;\n        case MessageType.SET:\n          {\n            parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);\n            returnValue = true;\n          }\n          break;\n        case MessageType.APPLY:\n          {\n            returnValue = rawValue.apply(parent, argumentList);\n          }\n          break;\n        case MessageType.CONSTRUCT:\n          {\n            const value = new rawValue(...argumentList);\n            returnValue = proxy(value);\n          }\n          break;\n        case MessageType.ENDPOINT:\n          {\n            const { port1, port2 } = new MessageChannel();\n            expose(obj, port2);\n            returnValue = transfer(port1, [port1]);\n          }\n          break;\n        case MessageType.RELEASE:\n          {\n            returnValue = undefined;\n          }\n          break;\n        default:\n          return;\n      }\n    } catch (value) {\n      returnValue = { value, [throwMarker]: 0 };\n    }\n    Promise.resolve(returnValue)\n      .catch((value) => {\n        return { value, [throwMarker]: 0 };\n      })\n      .then((returnValue) => {\n        const [wireValue, transferables] = toWireValue(returnValue);\n        ep.postMessage({ ...wireValue, id }, transferables);\n        if (type === MessageType.RELEASE) {\n          // detach and deactive after sending release response above.\n          ep.removeEventListener(\"message\", callback as any);\n          closeEndPoint(ep);\n        }\n      });\n  } as any);\n  if (ep.start) {\n    ep.start();\n  }\n}\n\nfunction isMessagePort(endpoint: Endpoint): endpoint is MessagePort {\n  return endpoint.constructor.name === \"MessagePort\";\n}\n\nfunction closeEndPoint(endpoint: Endpoint) {\n  if (isMessagePort(endpoint)) endpoint.close();\n}\n\nexport function wrap<T>(ep: Endpoint, target?: any): Remote<T> {\n  return createProxy<T>(ep, [], target) as any;\n}\n\nfunction throwIfProxyReleased(isReleased: boolean) {\n  if (isReleased) {\n    throw new Error(\"Proxy has been released and is not useable\");\n  }\n}\n\nfunction createProxy<T>(\n  ep: Endpoint,\n  path: (string | number | symbol)[] = [],\n  target: object = function () {}\n): Remote<T> {\n  let isProxyReleased = false;\n  const proxy = new Proxy(target, {\n    get(_target, prop) {\n      throwIfProxyReleased(isProxyReleased);\n      if (prop === releaseProxy) {\n        return () => {\n          return requestResponseMessage(ep, {\n            type: MessageType.RELEASE,\n            path: path.map((p) => p.toString()),\n          }).then(() => {\n            closeEndPoint(ep);\n            isProxyReleased = true;\n          });\n        };\n      }\n      if (prop === \"then\") {\n        if (path.length === 0) {\n          return { then: () => proxy };\n        }\n        const r = requestResponseMessage(ep, {\n          type: MessageType.GET,\n          path: path.map((p) => p.toString()),\n        }).then(fromWireValue);\n        return r.then.bind(r);\n      }\n      return createProxy(ep, [...path, prop]);\n    },\n    set(_target, prop, rawValue) {\n      throwIfProxyReleased(isProxyReleased);\n      // FIXME: ES6 Proxy Handler `set` methods are supposed to return a\n      // boolean. To show good will, we return true asynchronously ¯\\_(ツ)_/¯\n      const [value, transferables] = toWireValue(rawValue);\n      return requestResponseMessage(\n        ep,\n        {\n          type: MessageType.SET,\n          path: [...path, prop].map((p) => p.toString()),\n          value,\n        },\n        transferables\n      ).then(fromWireValue) as any;\n    },\n    apply(_target, _thisArg, rawArgumentList) {\n      throwIfProxyReleased(isProxyReleased);\n      const last = path[path.length - 1];\n      if ((last as any) === createEndpoint) {\n        return requestResponseMessage(ep, {\n          type: MessageType.ENDPOINT,\n        }).then(fromWireValue);\n      }\n      // We just pretend that `bind()` didn’t happen.\n      if (last === \"bind\") {\n        return createProxy(ep, path.slice(0, -1));\n      }\n      const [argumentList, transferables] = processArguments(rawArgumentList);\n      return requestResponseMessage(\n        ep,\n        {\n          type: MessageType.APPLY,\n          path: path.map((p) => p.toString()),\n          argumentList,\n        },\n        transferables\n      ).then(fromWireValue);\n    },\n    construct(_target, rawArgumentList) {\n      throwIfProxyReleased(isProxyReleased);\n      const [argumentList, transferables] = processArguments(rawArgumentList);\n      return requestResponseMessage(\n        ep,\n        {\n          type: MessageType.CONSTRUCT,\n          path: path.map((p) => p.toString()),\n          argumentList,\n        },\n        transferables\n      ).then(fromWireValue);\n    },\n  });\n  return proxy as any;\n}\n\nfunction myFlat<T>(arr: (T | T[])[]): T[] {\n  return Array.prototype.concat.apply([], arr);\n}\n\nfunction processArguments(argumentList: any[]): [WireValue[], Transferable[]] {\n  const processed = argumentList.map(toWireValue);\n  return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];\n}\n\nconst transferCache = new WeakMap<any, Transferable[]>();\nexport function transfer<T>(obj: T, transfers: Transferable[]): T {\n  transferCache.set(obj, transfers);\n  return obj;\n}\n\nexport function proxy<T>(obj: T): T & ProxyMarked {\n  return Object.assign(obj, { [proxyMarker]: true }) as any;\n}\n\nexport function windowEndpoint(\n  w: PostMessageWithOrigin,\n  context: EventSource = self,\n  targetOrigin = \"*\"\n): Endpoint {\n  return {\n    postMessage: (msg: any, transferables: Transferable[]) =>\n      w.postMessage(msg, targetOrigin, transferables),\n    addEventListener: context.addEventListener.bind(context),\n    removeEventListener: context.removeEventListener.bind(context),\n  };\n}\n\nfunction toWireValue(value: any): [WireValue, Transferable[]] {\n  for (const [name, handler] of transferHandlers) {\n    if (handler.canHandle(value)) {\n      const [serializedValue, transferables] = handler.serialize(value);\n      return [\n        {\n          type: WireValueType.HANDLER,\n          name,\n          value: serializedValue,\n        },\n        transferables,\n      ];\n    }\n  }\n  return [\n    {\n      type: WireValueType.RAW,\n      value,\n    },\n    transferCache.get(value) || [],\n  ];\n}\n\nfunction fromWireValue(value: WireValue): any {\n  switch (value.type) {\n    case WireValueType.HANDLER:\n      return transferHandlers.get(value.name)!.deserialize(value.value);\n    case WireValueType.RAW:\n      return value.value;\n  }\n}\n\nfunction requestResponseMessage(\n  ep: Endpoint,\n  msg: Message,\n  transfers?: Transferable[]\n): Promise<WireValue> {\n  return new Promise((resolve) => {\n    const id = generateUUID();\n    ep.addEventListener(\"message\", function l(ev: MessageEvent) {\n      if (!ev.data || !ev.data.id || ev.data.id !== id) {\n        return;\n      }\n      ep.removeEventListener(\"message\", l as any);\n      resolve(ev.data);\n    } as any);\n    if (ep.start) {\n      ep.start();\n    }\n    ep.postMessage({ id, ...msg }, transfers);\n  });\n}\n\nfunction generateUUID(): string {\n  return new Array(4)\n    .fill(0)\n    .map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16))\n    .join(\"-\");\n}\n"],"names":[],"mappings":"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"}