How to use type-detect - 10 common examples

if (isUndefined(config)) {
    // let the caller deal with this
    return config
  }
  let typeMessage = `Your config data type was`
  if (isFunction(config)) {
    config = config(input)
    typeMessage = `${typeMessage} a function which returned`
  }
  const emptyConfig = isEmpty(config)
  const plainObjectConfig = isPlainObject(config)
  if (plainObjectConfig && emptyConfig) {
    typeMessage = `${typeMessage} an object, but it was empty`
  } else {
    typeMessage = `${typeMessage} a data type of "${typeOf(config)}"`
  }
  if (!plainObjectConfig || emptyConfig) {
    log.error({
      message: chalk.red(
        oneLine`
          The package-scripts configuration
          ("${configPath.replace(/\\/g, '/')}") must be a non-empty object
          or a function that returns a non-empty object.
        `,
      ),
      ref: 'config-must-be-an-object',
    })
    throw new Error(typeMessage)
  }

  const defaultConfig = {

it('Should close connections without error.', function(done) {
    this.timeout(10000);
    expect(typeDetect(createOrGetServer)).to.equal('function');

    if (redisClient.quit) {
      redisClient.quit();
    }

    createOrGetServer().close();
    done();
  });
});

protected handleError(type: string, { reason, value }: Record) {
    switch (type) {
      case 'any.required':
      case 'object.base':
        return `expected a plain object value, but found [${typeDetect(value)}] instead.`;
      case 'object.allowUnknown':
        return `definition for this key is missing`;
      case 'object.child':
        return reason[0];
    }
  }

constructor(
    protected readonly options: Readonly,
    oidcOptions?: Readonly
  ) {
    super(options);
    if (!oidcOptions || !oidcOptions.realm) {
      throw new Error('Realm name must be specified');
    }

    if (type(oidcOptions.realm) !== 'string') {
      throw new Error('Realm must be a string');
    }

    this.realm = oidcOptions.realm as string;
  }

public handle(kibanaResponse: KibanaResponse) {
    if (!(kibanaResponse instanceof KibanaResponse)) {
      throw new Error(
        `Unexpected result from Route Handler. Expected KibanaResponse, but given: ${typeDetect(
          kibanaResponse
        )}.`
      );
    }

    return this.toHapiResponse(kibanaResponse);
  }

protected handleError(type: string, { value }: Record) {
    if (type === 'any.required' || type === 'boolean.base') {
      return `expected value of type [boolean] but got [${typeDetect(value)}]`;
    }
  }
}

(a: any, b: any) => {
      if (
        (typeDetect(a) === 'boolean' && typeDetect(b) === 'Object') ||
        (typeDetect(b) === 'boolean' && typeDetect(a) === 'Object')
      ) {
        throw new Error(`a boolean and an object can't be merged`);
      }

      if (typeDetect(a) === 'boolean' && typeDetect(b) === 'boolean' && a !== b) {
        throw new Error(`"true" and "false" can't be merged`);
      }
    }
  );

throw new Error(`Plugin "${this.name}" does not export "plugin" definition (${this.path}).`);
    }

    const { plugin: initializer } = pluginDefinition as {
      plugin: PluginInitializer;
    };
    if (!initializer || typeof initializer !== 'function') {
      throw new Error(`Definition of plugin "${this.name}" should be a function (${this.path}).`);
    }

    const instance = initializer(this.initializerContext);
    if (!instance || typeof instance !== 'object') {
      throw new Error(
        `Initializer for plugin "${
          this.manifest.id
        }" is expected to return plugin instance, but returned "${typeDetect(instance)}".`
      );
    }

    if (typeof instance.setup !== 'function') {
      throw new Error(`Instance of plugin "${this.name}" does not define "setup" function.`);
    }

    return instance;
  }
}

if (typeRegistration === undefined) {
      return attributes;
    }

    const encryptionAAD = this.getAAD(typeRegistration, descriptor, attributes);
    const decryptedAttributes: Record = {};
    for (const attributeName of typeRegistration.attributesToEncrypt) {
      const attributeValue = attributes[attributeName];
      if (attributeValue == null) {
        continue;
      }

      if (typeof attributeValue !== 'string') {
        this.audit.decryptAttributeFailure(attributeName, descriptor);
        throw new Error(
          `Encrypted "${attributeName}" attribute should be a string, but found ${typeDetect(
            attributeValue
          )}`
        );
      }

      try {
        decryptedAttributes[attributeName] = await this.crypto.decrypt(
          attributeValue,
          encryptionAAD
        );
      } catch (err) {
        this.log.error(`Failed to decrypt "${attributeName}" attribute: ${err.message || err}`);
        this.audit.decryptAttributeFailure(attributeName, descriptor);

        throw new EncryptionError(
          `Unable to decrypt attribute "${attributeName}"`,

/*!
 * Seed :: Query (utils) - MongoDB style array filtering
 * Copyright(c) 2011-2014 Jake Luer 
 * MIT Licensed
 */

var pathval = require('pathval');
var type = require('type-detect').Library();

var comparators = require('./comparators');

/*!
 * Custom type
 */

type.define('simplex', function(o) {
  if ('string' === type.of(o)) return true;
  if ('number' === type.of(o)) return true;
  if ('boolean' === type.of(o)) return true;
  return false;
})

/*!
 * Given the query input, create a re-usable definition