TypeScript io-client.default方法代码示例

export function initSocket(context: Context) {
  const core = context.getMethodsOf<CoreSpec>('core');
  if (!core.isDevServerOn()) {
    return;
  }

  socket = io();
  socket.on(SERVER_MESSAGE_EVENT_NAME, handleServerMessage);
  socket.on(RENDERER_MESSAGE_EVENT_NAME, handleRendererMessage);

  return () => {
    if (socket) {
      socket.off(SERVER_MESSAGE_EVENT_NAME, handleServerMessage);
      socket.off(RENDERER_MESSAGE_EVENT_NAME, handleRendererMessage);
      socket = undefined;
    }
  };

  function handleServerMessage(msg: Message) {
    context.emit('serverMessage', msg);
  }

  function handleRendererMessage(msg: Message) {
    context.emit('rendererResponse', msg);
  }
}

    return (dispatch, getState) => {
        dispatch({ type: 'CONNECTING' });
        // const socket = io({
        //     path: '/api/socket.io'
        // });
        const socket = io();

        socket.on('connect', () => {
            let username = getState().user.username;
            if (username) {
                socket.emit('login', { username }, (resp: Protocol.Response) => {
                    if (!resp.success) {
                        dispatch({ type: 'LOGOUT' });
                    } else {
                        dispatch({
                            type: 'CONNECTED',
                            payload: socket
                        });
                    }
                });
            } else {
                dispatch({
                    type: 'CONNECTED',
                    payload: socket
                });
            }
        });

        socket.on('disconnect', () => {
            dispatch({ type: 'DISCONNECTED' });
        });

        socket.on('canvas:history:new', (event: Protocol.NewHistoryEvent) => {
            dispatch({
                type: 'CANVAS_HISTORY_NEW',
                payload: event.entry
            });
        });

        socket.on('canvas:user:join', (event: Protocol.UserEvent) => {
            dispatch({
                type: 'CANVAS_USER_JOIN',
                payload: event.user
            });
        });

        socket.on('canvas:user:leave', (event: Protocol.UserEvent) => {
            dispatch({
                type: 'CANVAS_USER_LEAVE',
                payload: event.user
            });
        });

        socket.on('canvas:user:update', (event: Protocol.UserEvent) => {
            dispatch({
                type: 'CANVAS_USER_UPDATE',
                payload: event.user
            });
        });
    }

 constructor() {
   this.socket = io(HOST);
   this._app = feathers()
     .configure(socketio(this.socket))
     .configure(hooks())
     .configure(authentication({ storage: localstorage }));
 }

 constructor() {
     super();
     this.socket = io(HOST);
     this._app = feathers()
         .configure(socketio(this.socket))
         .configure(hooks())
 }

export function createWebSocketsConnect(url: string): RendererConnect {
  const socket = io(url);

  return {
    postMessage(msg) {
      socket.emit(RENDERER_MESSAGE_EVENT_NAME, msg);
    },

    onMessage(onMessage) {
      socket.on(RENDERER_MESSAGE_EVENT_NAME, onMessage);
      return () => socket.off(RENDERER_MESSAGE_EVENT_NAME, onMessage);
    }
  };
}

import io from 'socket.io-client'

import { SOCKET_IO_PORT } from '../shared/const'

console.log('env', process.env.NODE_ENV, process.env)

export const service = io(
  process.env.NODE_ENV === 'development'
    ? `http://localhost:${SOCKET_IO_PORT}`
    : `http://minesweepers.cubie.dns-cloud.net:${SOCKET_IO_PORT}/`,
  { transports: ['websocket'] }
)

function Socket(socketFactory) {
    'ngInject';
    // socket.io now auto-configures its connection when we ommit a connection url
    var ioSocket = io('', {
      // Send auth token on connection, you will need to DI the Auth service above
      // 'query': 'token=' + Auth.getToken()
      path: '/socket.io-client'
    });

    var socket = socketFactory({ ioSocket });

    return {
      socket,

      /**
       * Register listeners to sync an array with updates on a model
       *
       * Takes the array we want to sync, the model name that socket updates are sent from,
       * and an optional callback function after new items are updated.
       *
       * @param {String} modelName
       * @param {Array} array
       * @param {Function} cb
       */
      syncUpdates(modelName, array, cb) {
        cb = cb || angular.noop;

        /**
         * Syncs item creation/updates on 'model:save'
         */
        socket.on(modelName + ':save', function (item) {
          var oldItem = _.find(array, {_id: item._id});
          var index = array.indexOf(oldItem);
          var event = 'created';

          // replace oldItem if it exists
          // otherwise just add item to the collection
          if (oldItem) {
            array.splice(index, 1, item);
            event = 'updated';
          } else {
            array.push(item);
          }

          cb(event, item, array);
        });

        /**
         * Syncs removed items on 'model:remove'
         */
        socket.on(modelName + ':remove', function (item) {
          var event = 'deleted';
          _.remove(array, {_id: item._id});
          cb(event, item, array);
        });
      },

      /**
       * Removes listeners for a models updates on the socket
       *
       * @param modelName
       */
      unsyncUpdates(modelName) {
        socket.removeAllListeners(modelName + ':save');
        socket.removeAllListeners(modelName + ':remove');
      }
    };
  }

	connect(url: string, opts?: SocketIOClient.ConnectOpts, fn?: Function) {
		this.socket = io(url, opts);
		if (fn) this.onConnect(fn);
		return this;
	}

 commonTests(() => app, () => {
   return feathers()
     .configure(socketioClient(io('http://localhost:9777')))
     .configure(authClient());
 }, {

import feathers, { ClientApp } from '@feathersjs/feathers';
import socketio from '@feathersjs/socketio-client';
import io from 'socket.io-client';
import auth from '@feathersjs/authentication-client';

import events from './store/events';

const API_ENDPOINT = window.location.hostname === 'localhost'
  ? 'http://localhost:3000'
  : 'https://api.tf2pickup.net';
const SOCKET_TIMEOUT = 2000;

const socket = io(API_ENDPOINT, {
  path: '/ws/',
  transports: ['websocket'],
  reconnection: false,
  timeout: SOCKET_TIMEOUT,
  autoConnect: false,
});
const app: ClientApp = feathers();

app
  .configure(socketio(socket, { timeout: SOCKET_TIMEOUT }))
  .configure(auth({ storage: window.localStorage }))
  .configure(events());

export {
  API_ENDPOINT,
  socket,
};