How to use change-case - 10 common examples

module.exports = function (config) {

  var i, prefixCC, env, value, configuration, hierarchy = [];

  var conf = {};

  // Extend defaults with user configuration
  conf.prefix = (config && config.prefix) ? config.prefix : defaults.prefix;
  conf.arraySeparator = (config && config.arraySeparator) ? config.arraySeparator : defaults.arraySeparator;
  conf.defaults = (config && config.defaults) ? config.defaults : defaults.defaults;

  // Namespace (prefix) for config env variables
  prefixCC = changeCase.constantCase(conf.prefix);
  // Create config object
  configuration = new Config(conf.defaults);
  // Iterate over env vars
  for (env in process.env) {
    // if env is in app namespace
    if (env.indexOf(prefixCC) === 0) {
      // split each var using separator
      hierarchy = env.replace(prefixCC !== '' ? prefixCC + '_' : prefixCC, '').split('_');

      // Array property ?
      if (conf.arraySeparator && process.env[env].indexOf(conf.arraySeparator) !== -1) {
        value = process.env[env].split(conf.arraySeparator);
        // Try to parse each element in array
        for (i = 0; i < value.length; i = i + 1) {
          try {
            value[i] = JSON.parse(value[i]);

constructor: function () {
    // Calling the super constructor is important so our generator is correctly set up
    helpers.NamedBase.apply(this, arguments);
    this.log(
      'Creating route to module ' + chalk.green(this.name) + ' using '
      + chalk.green((this.config.get('uirouter') && 'UI Router') || 'Angular Router')
    );

    this.choices = {
      name: changeCase.camelCase(this.name),
      namePascalCase: changeCase.pascalCase(this.name),
      nameParamCase: changeCase.paramCase(this.name)
    };
  },

Config.prototype.extend = function (array, value, conf) {

  conf = conf || this.conf;
  var propName = null;

  // Last property in hierarchy
  if (array && array.length === 1) {
    conf[changeCase.camelCase(array[0])] = value;
  } else if (array && array.length > 1) {
    propName = array[0];
    propName = changeCase.camelCase(propName);
    // if object is not on conf. hierarchy
    if (array[0] && conf[propName] === undefined) {
      conf[propName] = {};
    }
    this.extend(array.slice(1), value, conf[propName]);
  }

};

let name = newLayerName.replace(/%\*u%/gi, changeCase.upperCase(layerName))

  // LowerCase
  name = name.replace(/%\*l%/gi, changeCase.lowerCase(layerName))

  // Title Case
  name = name.replace(/%\*t%/gi, toTitleCase(layerName))

  // UpperCase First
  name = name.replace(/%\*uf%/gi, changeCase.upperCaseFirst(layerName))

  // Camel Case
  name = name.replace(/%\*c%/gi, changeCase.camelCase(layerName))

  // Param Case
  name = name.replace(/%\*pc%/gi, changeCase.paramCase(layerName))

  // Layername
  name = name.replace(/%\*/g, layerName)

  return name
}

if (response.statusCode === 404) {
            return reject(new Error('Your card is not supported'))
          }
          if (response.statusCode === 422) {
            return reject(new Error(i18n.__('fieldErrors.fields.cardNo.message')))
          }
          // if the server is down, or returns non 500, just continue
          if (response.statusCode !== 200) {
            return resolve()
          }

          const body = response.body

          const card = {
            brand: changeCase.paramCase(body.brand),
            type: normaliseCardType(body.type),
            corporate: body.corporate,
            prepaid: body.prepaid
          }

          logger.debug(`[${correlationId}] Checking card brand`, {
            cardBrand: card.brand,
            cardType: card.type
          })

          if (_.filter(allowed, { brand: card.brand }).length === 0) {
            reject(new Error(i18n.__('fieldErrors.fields.cardNo.unsupportedBrand', changeCase.titleCase(card.brand))))
          }

          if (!_.find(allowed, { brand: card.brand, type: card.type })) {
            switch (card.type) {

.then((post) => {
      if (!post) {
        return res.status(404).send({
          error: 'No post found'
        });
      }

      // Update the post slug based on the title if title is new
      const postTitle = req.body.postTitle ? req.body.postTitle.trim() : null;
      if (req.body.postTitle && !post.dataValues.postSlug.includes(`${changeCase.paramCase(postTitle)}`)) {
        let slug = postTitle ? `${changeCase.paramCase(postTitle)}-${Date.now()}` : null;
        req.body.postSlug = slug;
      }

      let termsPromises = [];

      if (req.body.postTerms) {
        post.setPostTerms();
        req.body.postTerms.forEach((term) => {
          let { termType, termName } = term;
          term.termSlug = `${changeCase.paramCase(termType)}-${changeCase.paramCase(termName)}`;
          let termReq = Term.findOrCreate({where: {termSlug: term.termSlug}, defaults: { termType, termName }})
            .spread((term2) => {
              post.addPostTerm(term2);
            });
          termsPromises.push(termReq);
        });

function scaffold(type, subModule, name, createNewSubModule, cb) {

    var componentPath = type + 's/' + subModule + '/' + name;

    var ops = {
      name: name,
      type: type,
      subModule: subModule,
      camel: changeCase.camel(name)
    };

    if (createNewSubModule) {
      fs.mkdirSync('src/' + type + 's/' + subModule);
    }

    // certain types need special variables
    switch (type) {
      case 'directive':
        ops.camel = 'li' + changeCase.pascalCase(subModule) + changeCase.pascalCase(name);
        ops.markup = 'li:' + [subModule, name].join('-');
        ops.cssClass = ['lia', subModule, name].join('-');
        break;
      case 'service':
        ops.camel = '$li' + changeCase.pascalCase(name);
        break;

loadFromEnv (env?: NodeJS.ProcessEnv) {
    if (!env) {
      env = process.env
    }

    // Copy all env vars starting with ENV_PREFIX into a set so we can check off
    // the ones we recognize and warn the user about any we don't recognize.
    const unrecognizedEnvKeys = new Set(
      Object.keys(env).filter(key => key.startsWith(ENV_PREFIX))
    )

    const config = {}
    for (let key of Object.keys(configSchema.properties)) {
      const envKey = ENV_PREFIX + constantCase(key)
      const envValue = env[envKey]

      unrecognizedEnvKeys.delete(envKey)
      if (typeof envValue === 'string') {
        switch (configSchema.properties[key].type) {
          case 'string':
            config[key] = envValue
            break
          case 'object':
          case 'array':
            try {
              config[key] = JSON.parse(envValue)
            } catch (err) {
              logger.error('unable to parse config. key=%s' + envKey)
            }
            break

async function expand(responseBody, __, includeFullObject, prune) {
    __ = __ || i18n.__;
    let fieldConstantCase = changeCase.constantCase(responseBody.field);
    // if enum then look up value
    // else get item from API
    if (!_.has(config.fields[fieldConstantCase], 'type')) {
        // throw 'No such facet type configured';
        // default to raw
        config.fields[fieldConstantCase] = {type: config.type.RAW};
    }

    // Preprocess
    // Notice that sorting makes little sense if the list isn't exhaustive
    if (config.fields[fieldConstantCase].ordering === 'NUMERIC') {
        responseBody.results = _.sortBy(responseBody.results, function(e) {
            return _.toSafeInteger(e.name);
        });
    }
    if (prune && config.fields[fieldConstantCase].prune) {

function getRanges(field, minMax, buckets) {
    // based on the field type and minimum resolution and min max values returns an array with min max values
    // let range = ['1900,1910', '1910,1920', '1920,1930', '1930,1940'];
    let constantField = changeCase.constantCase(field);
    let bucketSizeVaries = false;

    let diff = minMax.max - minMax.min;
    let bucketSize = diff / buckets;

    // an attempt to set buckets size to nice values (0.1 instead of 0.1043429) whilst keeping bucket count to around 10;
    if (diff > 0.0000001) {
        let b = 10000;
        while (diff <= b) {
            b /= 10;
        }
        b /= 10;
        if (diff / b > 20) b *= 5;
        if (diff / b > 15) b *= 2;
        if (diff / b < 3) b /= 5;
        if (diff / b < 5) b /= 2;