decord/source/217__isNativeReflectConstruct.js

// Module ID: 217
// Function ID: 218
// Name: _isNativeReflectConstruct
// Dependencies: [109, 41, 42, 93, 95, 98, 209, 218, 38, 200, 203, 212, 206, 220, 133, 221, 205, 132]

// Module 217 (_isNativeReflectConstruct)
import _modDef38 from "module_38" /* 38 */;
import _inheritsDefault from "_inherits" /* 98 */;
import dispatchDefault from "dispatch" /* 132 */;
import BlobManagerDefault from "BlobManager" /* 200 */;
import BlobDefault from "Blob" /* 203 */;
import NativeEventEmitterDefault from "NativeEventEmitter" /* 209 */;
import WebSocketModuleDefault from "WebSocketModule" /* 218 */;
import closure_4 from "_objectWithoutProperties" /* 109 */;
import closure_5 from "_classCallCheck" /* 41 */;
import closure_6 from "_possibleConstructorReturn" /* 93 */;
import closure_7 from "_getPrototypeOf" /* 95 */;
import importDefaultResult from "_createClass" /* 42 */;

const WebSocket = arg1;
function _isNativeReflectConstruct() {
  try {
    const _Boolean = Boolean;
    const call = valueOf.call;
    const _Reflect = Reflect;
    const _Boolean2 = Boolean;
    if (typeof call === "unknown") {
      let callResult = valueOf();
    } else {
      callResult = call(constructResult);
    }
    closure_0 = !callResult;
    _isNativeReflectConstruct = function _isNativeReflectConstruct() {
      return closure_0;
    };
    return _isNativeReflectConstruct();
  } catch (err) {
  }
}
let closure_3 = ["headers"];
let closure_9 = 0;
class WebSocket {
  constructor(arg0, arg1, arg2) {
    self = this;
    tmp3 = closure_5(this, WebSocket);
    tmp4 = closure_7;
    obj = closure_7(WebSocket);
    tmp5 = closure_6;
    if (_isNativeReflectConstruct()) {
      tmp7 = globalThis;
      _Reflect = Reflect;
      constructResult = Reflect.construct(obj, [], tmp4(self).constructor);
    } else {
      constructResult = obj.apply(self, undefined);
    }
    tmp5Result = tmp5(self, constructResult);
    tmp5Result.CONNECTING = 0;
    tmp5Result.OPEN = 1;
    tmp5Result.CLOSING = 2;
    tmp5Result.CLOSED = 3;
    tmp5Result.readyState = 0;
    tmp5Result.url = global;
    tmp8 = arg1;
    if (typeof arg1 === "string") {
      items = [];
      items[0] = arg1;
      tmp8 = items;
    }
    obj = importDefault;
    if (!importDefault) {
      obj = {};
    }
    headers = obj.headers;
    if (undefined === headers) {
      headers = {};
    }
    tmp9 = closure_4(obj, closure_3);
    tmp10 = tmp9;
    if (tmp9) {
      tmp10 = typeof tmp9.origin === "string";
    }
    if (tmp10) {
      tmp11 = globalThis;
      _console = console;
      str = "Specifying `origin` as a WebSocket connection option is deprecated. Include it under `headers` instead.";
      warnResult = console.warn("Specifying `origin` as a WebSocket connection option is deprecated. Include it under `headers` instead.");
      headers.origin = tmp9.origin;
      str2 = "origin";
      delete tmp2[tmp];
    }
    if (Object.keys(tmp9).length > 0) {
      _console2 = console;
      _Object = Object;
      keys = Object.keys(tmp9);
      str3 = "`, `";
      str4 = "Unrecognized WebSocket connection option(s) `";
      str5 = "`. Did you mean to put these under `headers`?";
      warnResult1 = console.warn(`Unrecognized WebSocket connection option(s) \`${obj5.join("`, `")}\`. Did you mean to put these under \`headers\`?`);
    }
    tmp14 = tmp8;
    if (!Array.isArray(tmp8)) {
      tmp14 = null;
    }
    tmp15 = new require("NativeEventEmitter")(null);
    tmp5Result._eventEmitter = tmp15;
    tmp16 = +closure_9;
    closure_9 = tmp16 + 1;
    tmp5Result._socketId = tmp16;
    _registerEventsResult = tmp5Result._registerEvents();
    obj6 = require("WebSocketModule");
    obj1 = { headers };
    connectResult = obj6.connect(global, tmp14, obj1, tmp5Result._socketId);
    return tmp5Result;
  }
}
_inheritsDefault(WebSocket, dispatchDefault);
let items = [
  {
    key: "binaryType",
    get() {
      return this._binaryType;
    },
    set(_binaryType) {
      if ("blob" !== _binaryType) {
        if ("arraybuffer" !== _binaryType) {
          const _Error = Error;
          error = new Error("binaryType must be either 'blob' or 'arraybuffer'");
          throw error;
        }
      }
      const self = this;
      if (!tmp2) {
        _modDef38(BlobManagerDefault.isAvailable, "Native module BlobModule is required for blob support");
        if ("blob" === _binaryType) {
          let tmp3Result = tmp3(200);
          tmp3Result.addWebSocketHandler(self._socketId);
        } else {
          tmp3Result = tmp3(200);
          const result = tmp3Result.removeWebSocketHandler(self._socketId);
        }
        const tmp5 = _modDef38;
      }
      self._binaryType = _binaryType;
    }
  },
  {
    key: "close",
    value: function close(arg0, arg1) {
      const self = this;
      if (tmp) {
        self.readyState = self.CLOSING;
        self._close(arg0, arg1);
      }
    }
  },
  {
    key: "send",
    value: function send(str) {
      const self = this;
      if (this.readyState === this.CONNECTING) {
        const _Error2 = Error;
        error = new Error("INVALID_STATE_ERR");
        throw error;
      } else if (str instanceof BlobDefault) {
        let tmp16Result = tmp16(38);
        tmp16Result(tmp16(200).isAvailable, "Native module BlobModule is required for blob support");
        tmp16Result = tmp16(200);
        tmp16Result.sendOverSocket(str, self._socketId);
      } else if (typeof str !== "string") {
        const _ArrayBuffer = ArrayBuffer;
        if (!(str instanceof ArrayBuffer)) {
          const _ArrayBuffer2 = ArrayBuffer;
          if (!ArrayBuffer.isView(str)) {
            const _Error = Error;
            const error1 = new Error("Unsupported data type");
            throw error1;
          }
        }
        tmp16(218).sendBinary(tmp16(212)(str), self._socketId);
        const tmp16Result1 = tmp16(218);
      } else {
        tmp16(218).send(str, self._socketId);
        const tmp16Result2 = tmp16(218);
      }
    }
  },
  {
    key: "ping",
    value: function ping() {
      if (this.readyState === this.CONNECTING) {
        const _Error = Error;
        error = new Error("INVALID_STATE_ERR");
        throw error;
      } else {
        WebSocketModuleDefault.ping(tmp._socketId);
      }
    }
  },
  {
    key: "_close",
    value: function _close(num, str) {
      num = 1000;
      str = "";
      const self = this;
      WebSocketModuleDefault.close(num, str, this._socketId);
      let isAvailable = BlobManagerDefault.isAvailable;
      if (isAvailable) {
        isAvailable = "blob" === self._binaryType;
      }
      if (isAvailable) {
        const result = BlobManagerDefault.removeWebSocketHandler(self._socketId);
        const tmpResult = BlobManagerDefault;
      }
    }
  },
  {
    key: "_unregisterEvents",
    value: function _unregisterEvents() {
      const _subscriptions = this._subscriptions;
      const item = _subscriptions.forEach((remove) => remove.remove());
      this._subscriptions = [];
    }
  },
  {
    key: "_registerEvents",
    value: function _registerEvents() {
      const self = this;
      const _eventEmitter = this._eventEmitter;
      const items = [
        _eventEmitter.addListener("websocketMessage", (id) => {
          let dispatchEventResult = id;
          let obj = self;
          if (id.id === self._socketId) {
            ({ data, type } = dispatchEventResult);
            if ("binary" === type) {
              data = closure_1_1(closure_1_2[12]).toByteArray(dispatchEventResult.data).buffer;
              const obj3 = closure_1_1(closure_1_2[12]);
            } else if ("blob" === type) {
              data = closure_1_1(closure_1_2[9]).createFromOptions(dispatchEventResult.data);
              const obj2 = closure_1_1(closure_1_2[9]);
            }
            obj = { data: null, raw_length: null };
            obj[0] = data;
            obj[1] = dispatchEventResult.raw_length;
            const tmp11 = new closure_1_1(closure_1_2[13])("message", obj);
            dispatchEventResult = obj.dispatchEvent(tmp11);
          }
        }),
      ,
      ,

      ];
      const _eventEmitter2 = this._eventEmitter;
      items[1] = _eventEmitter2.addListener("websocketOpen", (id) => {
        if (id.id === self._socketId) {
          obj.readyState = obj.OPEN;
          obj.protocol = id.protocol;
          const tmp5 = new closure_1_1(closure_1_2[14])("open");
          obj.dispatchEvent(tmp5);
        }
      });
      const _eventEmitter3 = this._eventEmitter;
      items[2] = _eventEmitter3.addListener("websocketClosed", (id) => {
        let obj = self;
        if (id.id === self._socketId) {
          obj.readyState = obj.CLOSED;
          obj = { code: null, reason: null };
          ({ code: obj2[0], reason: obj2[1] } = id);
          const tmp6 = new closure_1_1(closure_1_2[15])("close", obj);
          obj.dispatchEvent(tmp6);
          obj._unregisterEvents();
          obj.close();
        }
      });
      const _eventEmitter4 = this._eventEmitter;
      items[3] = _eventEmitter4.addListener("websocketFailed", (id) => {
        let obj = self;
        if (id.id === self._socketId) {
          obj.readyState = obj.CLOSED;
          const tmp5 = new closure_1_1(closure_1_2[14])("error");
          obj.dispatchEvent(tmp5);
          obj = { code: 1006, reason: null };
          obj[1] = id.message;
          const tmp11 = new closure_1_1(closure_1_2[15])("close", obj);
          obj.dispatchEvent(tmp11);
          obj._unregisterEvents();
          obj.close();
        }
      });
      this._subscriptions = items;
    }
  },
  {
    key: "onclose",
    get() {
      return WebSocket(205).getEventHandlerAttribute(this, "close");
    },
    set(fn) {
      const result = WebSocket(205).setEventHandlerAttribute(this, "close", fn);
    }
  },
  {
    key: "onerror",
    get() {
      return WebSocket(205).getEventHandlerAttribute(this, "error");
    },
    set(fn) {
      const result = WebSocket(205).setEventHandlerAttribute(this, "error", fn);
    }
  },
  {
    key: "onmessage",
    get() {
      return WebSocket(205).getEventHandlerAttribute(this, "message");
    },
    set(fn) {
      const result = WebSocket(205).setEventHandlerAttribute(this, "message", fn);
    }
  },
  {
    key: "onopen",
    get() {
      return WebSocket(205).getEventHandlerAttribute(this, "open");
    },
    set(fn) {
      const result = WebSocket(205).setEventHandlerAttribute(this, "open", fn);
    }
  }
];
const importDefaultResultResult = importDefaultResult(WebSocket, items);
importDefaultResultResult.CONNECTING = 0;
importDefaultResultResult.OPEN = 1;
importDefaultResultResult.CLOSING = 2;
importDefaultResultResult.CLOSED = 3;

export default importDefaultResultResult;