Narcoleptic Programmers' Medicine


    0.0.10 • Public • Published


    Letter Case Transformer

    build status of total downloads of leca leca's License latest version of leca

    To define your own letter case style and to deal with text by it. Or, to deal with text with predefined letter case styles.

    Predefined Case Styles

    predefined case case name example remark
    leca.bicaps* BiCapitalization AltaVista
    leca.camel camelCase missYou
    leca.kebab kebab-case i-love-you
    leca.lowercamel lowerCamelCase missYou s.a. camelCase
    leca.pascal PascalCase PostScript
    leca.sentence Sentence case I love you
    leca.snake snake_case i_love_you
    leca.title* Title Case I Love Your
    leca.uppercamel* UpperCamelCase PostScript s.a. PascalCase
    1. Case postfixed with asterisk * may be in dispute with its impletation in leca. Please BE CAREFUL by yourself when using them.
    2. s.a. = the same as
    3. Because of its arbitrariness and creation, it unable to parse a phrase in StUdLyCaPs.

    Table of contents


    Get Started

    Use predefined common case styles:

    const leca = require('leca');
    // RETURN true
    leca.camle.test('camel case');
    // RETURN false
    // RETURN [ "camel", "case" ];
    leca.camel.format('Camel', 'CASE');
    // RETURN "camelCase"

    Or, create your own case style:

    const leca = require('leca');
    const myCase = new leca.Case({
      // Used to split a formatted string.
      splitter: /(?=[A-Z])/,
      // Used to transform a word on formatting.
      wordFormatter: (word, index) => {
        if (index == 0) {
          return word.toLowerCase();
        else {
          return word.charAt(0).toUpperCase() + word.slice(1).toLowerCase();
      // Used to transform a word on parsing.
      wordParser: (word) => {
        return /^[a-zA-Z]+$/.test(word) ? word.toLowerCase() : false;
    myCase.test('camelCase');       // RETURN true
    myCase.test('camel case');      // RETURN false
    myCase.parse('camelCase');      // RETURN [ "camel", "case" ]
    myCase.format('Camel', 'CASE'); // RETURN "camelCase"



    An instance of class leca.Case represents a case style.

    • class leca.Case(object options)
      Hereafter use <ci> to represent an instance of leca.Case. See below for details of options.

    • boolean <ci>.test(string text)
      Return true if text matches the <ci>. Otherwise return false.

    • string[] | false <ci>.parse(string text)
      Split text into words.
      false will be returned if text doesnot match the case (e.g. doesnot start with options.prefix).

    • string | false <ci>.format(string[] words | ...words)
      Combine the words together according to the case format.
      false will be returned if any word doesnot match the case (depends on options.wordFormatter).

    • string | false <ci>.reformat(string text)
      Parse the text and format the words according to the case's format rule.

    Following options may be used in new leca.Case(options) to define a letter case:

    • options.prefix string OPTIONAL
      What matching texts start with.

    • options.postfix string OPTIONAL
      What matching texts end with.

    • options.jointer string | Function OPTIONAL DEFAULT ""
      Used in formatting.
      As a string, it will be put between every two words.
      As a function, it should conform to:

       * @param {number} [index] 
       * @param {string} [left] 
       * @param {string} [right] 
       * @return {string} 
      function(index, left, right) {
          // ...
    • options.splitter string | RegExp OPTIONAL
      Used in parsing.

    • options.terms string[] OPTIONAL
      Words to be preserved with its original style.
      In other words, the terms will escape from the constrains of options.wordFormatter and options.wordParser.

    • options.wordFormatter Function OPTIONAL
      Used in formatting.
      It should conform to:

       * @param {string}  word 
       * @param {number} [index] 
       * @param {number} [length] Total count of words
       * @return {string} 
      function(word, index, length) {
          // ...
    • options.wordParser Function OPTIONAL
      Used in parsing.
      It should conform to:

       * @param {string}  word 
       * @param {number} [index] 
       * @param {number} [length] Total count of words
       * @return {string | false}
      function(word, index, length) {
          // ...

    Predefined Common Letter Cases

    For the convenience of developers, the most frequently-used letter case styles are predefined. Developers may access a predefined case style in form of leca.<stylename>, e.g.

    const leca = require('leca');
    // Access the predefined case style named "camel".
    const mycase = leca.camel;
    // ATTENTION: All predefined style names are lowercase, and there are no 
    // punctuations or word "case" in names. Please DO NOT take the following for 
    // granted:
    leca.Pascal         // undefined
    leca.camelCase      // undefined
    leca['kebab-case']  // undefined
    leca.snake_case     // undefined
    // For those who have some kind of compulsive disorder, or just only wanna make
    // code more comprehensible, invoke `leca()` may be helpful:
    leca('Pascal')     === leca.pascal
    leca('camelCase')  === leca.camel
    leca('kebab-case') === leca.kebab
    leca('snake_case') === leca.snake

    In addition, some (acctually only 1 so far) accompanying methods are offered for each predefined letter case:

    • Case leca.*.terms(string | string[] terms)
      Return case instance based on corresponding predfined leca.Case. e.g.
      leca.camelCase.terms(['HTTP', 'HTTPS']).parse('myHTTPClient');
      // RETURN [ "my", "HTTP", "client" ]

    This is multi-cultural world, and a letter case style will be named differently in different occassions. With respect to more people, leca offers some alias for the foregoing predefined case style.

    See the table at beginning of this document for available predefined case styles.


    Developers can learn how to create own letter case by leca via unit tests and predefined common letter cases:



    npm i leca

    DownloadsWeekly Downloads






    Unpacked Size

    37.5 kB

    Total Files


    Last publish


    • youngoat
    • youngoat.elite