Top 10 Examples of "is-type-of in functional component" in JavaScript

function getProperties(filepath, { caseStyle }) {
  // if caseStyle is function, return the result of function
  if (is.function(caseStyle)) {
    const result = caseStyle(filepath);
    assert(is.array(result), `caseStyle expect an array, but got ${result}`);
    return result;
  }
  // use default camelize
  return defaultCamelize(filepath, caseStyle);
}

proto.get = async function get(name, file, options) {
  let writeStream = null;
  let needDestroy = false;

  if (is.writableStream(file)) {
    writeStream = file;
  } else if (is.string(file)) {
    writeStream = fs.createWriteStream(file);
    needDestroy = true;
  } else {
    // get(name, options)
    options = file;
  }

  options = options || {};
  if (options.process) {
    options.subres = options.subres || {};
    options.subres['x-oss-process'] = options.process;
  }

  let result;
  try {
    const params = this._objectRequestParams('GET', name, options);

_onMessage(message) {
    if (message && is.string(message.action)) {
      debug('[%s] got message %s with %j, receiverPid: %s',
        this.pid, message.action, message.data, message.receiverPid);
      this.emit(message.action, message.data);
    }
  }

_onMessage(message) {
    if (message && is.string(message.action)) {
      debug('[%s] got message %s with %j', this.pid, message.action, message.data);
      this.emit(message.action, message.data);
    }
  }

loadFile(filepath, ...inject) {
    if (!fs.existsSync(filepath)) {
      return null;
    }
    const ret = utils.loadFile(filepath);
    if (inject.length === 0) inject = [ this.app ];
    return isFunction(ret) ? ret(...inject) : ret;
  }

close() {
    if (is.function(this._client.close)) {
      return this._client.close();
    }
    return cluster.close(this._client);
  }

replacePort(str) {
    if (!is.string(str)) return str;
    return str.replace('{port}', this.app.config.assets.devServer.port);
  }

function addPrefix(prefix, path) {
  assert(is.string(path), `only support path with string, but got ${path}`);
  return prefix + path;
}

makeCustomHeaderToNet() {
    const customHeader = this.customHeader;
    if (!customHeader) {
      return;
    }

    this.extFields = this.extFields || {};
    for (const key in customHeader) {
      const field = customHeader[key];
      if (is.nullOrUndefined(field) || is.function(field)) {
        continue;
      }
      this.extFields[key] = field;
    }
  }

bindClass(exports) {
    if (is.class(exports) || is.function(exports)) {
      this.bindModule(exports);
    } else {
      for (const m in exports) {
        const module = exports[m];
        if (is.class(module) || is.function(module)) {
          this.bindModule(module);
        }
      }
    }
  }