TypeScript isstring.default方法代码示例

export default function (options: any, payload: MessagePayload, cb: (err: Error, payload: MessagePayload, message: Message) => void): Requester {
  if (isString(options)) {
    options = {
      namespace: options,
      waitForResponses: 1,
    };
  } else if (!("waitForResponses" in options)) {
    options.waitForResponses = 1;
  }

  options = clone(options);

  const channelManager = options.channelManager;
  delete(options.channelManager);

  const originalMessage = options.originalMessage;
  delete(options.originalMessage);

  const responseSchema = options.responseSchema;
  delete(options.responseSchema);

  const requester = new Requester(options, originalMessage);
  let responsePayload: MessagePayload;
  let responseMessage: Message;

  let onResponseFn = function (payloadInResponseFn: MessagePayload, message: Message): void {
    responsePayload = payloadInResponseFn;
    responseMessage = message;
  };

  if (responseSchema) {
    onResponseFn = validateWithSchema.onEvent(responseSchema, onResponseFn);
  }

  if (channelManager) {
    requester.channelManager = channelManager;
  }

  requester
    .on("payload", onResponseFn)
    .once("error", cb)
    .once("end", (): void => {
      cb(null, responsePayload, responseMessage);
    });

  return requester.publish(payload);
};

 public on(argu0: any, argu1?: any, argu2?: any, argu3?: any): any {
   const eventData: IEventArgu = {
     events: {},
     data: null,
     selector: null,
   };
   let isEvents = false;
   const falseHandler: (eventObject: J3Event, ...extraParameter: any[]) => void = function(e) {
     e.preventDefault();
     e.stopPropagation();
   };
   switch (true) {
     case isString(argu0):
       eventData.events[argu0] = null;
       break;
     case isPlainObject(argu0):
       isEvents = true;
       eventData.events = argu0;
       break;
     default:
       throw new Error("Argument type is not correct");
   }
   switch (true) {
     case (isUndefined(argu1) && isEvents):
       break;
     case (isFunction(argu1) && !isEvents):
       eventData.events[argu0] = argu1;
       break;
     case (argu1 === false):
       eventData.events[argu1] = falseHandler;
       break;
     case isString(argu1):
       eventData.selector = argu1;
       switch (true) {
         case (isUndefined(argu2) && isEvents):
           break;
         case (isFunction(argu2) && !isEvents):
           eventData.events[argu0] = argu2;
           break;
         case (argu2 === false):
           eventData.events[argu2] = falseHandler;
           break;
         case isArray(argu2) || isPlainObject(argu2):
           eventData.data = argu2;
           switch (true) {
             case (isUndefined(argu3) && isEvents):
               break;
             case (isFunction(argu3) && !isEvents):
               eventData.events[argu0] = argu3;
               break;
             case (argu3 === false):
               eventData.events[argu3] = falseHandler;
               break;
             default:
               throw new Error("Argument type is not correct");
           }
           break;
         default:
           throw new Error("Argument type is not correct");
       }
       break;
     case isArray(argu1) || isPlainObject(argu1):
       eventData.data = argu1;
       switch (true) {
         case (isUndefined(argu2) && isEvents):
           break;
         case (isFunction(argu2) && !isEvents):
           eventData.events[argu0] = argu2;
           break;
         case (argu2 === false):
           eventData.events[argu2] = falseHandler;
           break;
         default:
           throw new Error("Argument type is not correct");
       }
       break;
     default:
       throw new Error("Argument type is not correct");
   }
   if (eventData.selector) {
     throw new Error("Not implemented yet");
   }
   Object.keys(eventData.events).forEach((eventTypeString) => {
     this.__getArray().forEach((node) => {
       let eventOrganizer = node.props.getProp<EventOrganizer>("event");
       if (!eventOrganizer) {
         eventOrganizer = new EventOrganizer(node);
         node.props.setProp("event", eventOrganizer);
       }
       eventOrganizer.capture(eventTypeString, eventData.events[eventTypeString], eventData.data);
     });
   });
   return this;
 }

 public off(argu0?: any, argu1?: any, argu2?: any): any {
   const eventData: IEventArgu = {
     events: {},
     data: null,
     selector: null,
   };
   let removeAll = false;
   let isEvents = false;
   switch (true) {
     case isUndefined(argu0):
       removeAll = true;
       break;
     case isString(argu0):
       eventData.events[argu0] = null;
       break;
     case isPlainObject(argu0):
       isEvents = true;
       eventData.events = argu0;
       break;
     default:
       throw new Error("Argument type is not correct");
   }
   switch (true) {
     case (removeAll):
     case (isUndefined(argu1) && isString(argu0)):
     case (isUndefined(argu1) && isEvents):
       break;
     case (isFunction(argu1) && !isEvents):
       eventData.events[argu0] = argu1;
       break;
     case isString(argu1):
       eventData.selector = argu1;
       switch (true) {
         case (isUndefined(argu2) && isEvents):
           break;
         case (isFunction(argu2) && !isEvents):
           eventData.events[argu0] = argu2;
           break;
         default:
           throw new Error("Argument type is not correct");
       }
       break;
     default:
       throw new Error("Argument type is not correct");
   }
   if (eventData.selector) {
     throw new Error("Not implemented yet");
   }
   if (removeAll) {
     this.__getArray().forEach((node) => {
       let eventOrganizer = node.props.getProp<EventOrganizer>("event");
       if (eventOrganizer) {
         eventOrganizer.releaseAll();
       }
     });
   } else {
     Object.keys(eventData.events).forEach((eventTypeString) => {
       this.__getArray().forEach((node) => {
         let eventOrganizer = node.props.getProp<EventOrganizer>("event");
         if (eventOrganizer) {
           if (eventData.events[eventTypeString]) {
             eventOrganizer.release(eventTypeString, eventData.events[eventTypeString]);
           } else {
             eventOrganizer.releaseAll(eventTypeString);
           }
         }
       });
     });
   }
 }

    exchange.declare((errInExchangeDeclare) => {
      if (errInExchangeDeclare) return done(errInExchangeDeclare);

      const queueOptions = this.getQueueOptions();
      const queue = connection.queue(queueOptions);
      const bindingKeys = !config.bindingKeys ? [""] :
        isString(config.bindingKeys) ? [config.bindingKeys] : config.bindingKeys;

      queue.declare(queueOptions, (errInQueueDeclare) => {
        if (errInQueueDeclare) return done(errInQueueDeclare);

        for (let bindingKey of bindingKeys) {
          queue.bind(config.channel, bindingKey, (errInQueueBind) => {
            if (errInQueueBind) return done(errInQueueBind);
            if (this.isClosed) return; // Skip if already closed

            if (consumer) {
              this.consumer.resume(done);
            } else {
              this.consumer = consumer = connection.consume(queueOptions.queue, clone(queueOptions), (envelope) => this.onMessage(envelope), done);
              consumer.on("error", (err) => this.onConsumerError(err));
            }
          });
        }
      });
    });