godprotocol/Datatypes/str.js

A distributed computing environment

import Storage from "./functions/storage";

class Str extends Storage {
  constructor(config, manager) {
    super(manager)

    this.config = config
    this.type = 'string'
  }

  call = async (name, args)=>{
    let result, other, me = await this.literal();

    switch(name){
      case 'upper':
        result = me.toUpperCase();
        break;
      case 'lower':
        result = me.toLowerCase();
        break;
      case 'title':
        result = "";
        me = me.split(' ').map(m=>{
          result = `${result} ${m[0].toUpperCase()}${m.slice(1).toLowerCase()}`.trim()
        })
        break;
      case 'slice':
        let start = args[0], end = args[1];
        start = start && await start.literal()
        end = end && await end.literal()

        result = me.slice(start, end)
        break;
      case 'concat':
        other = await args[0].literal()
        result = `${me}${other}`
        break;
      case 'find':
        other = args[0]
        let lst = args[1] && await args[1].literal()
        result = me[lst?'lastIndexOf': 'indexOf'](await other.literal())
        break;
      case 'includes':
        other = args[0]
        result = me.includes(await other.literal())
        break;
      case 'index':
        other = await args[0].literal()
        if (other < 0){
          result = me.slice(other)[0]
        }else result = me[other]
        break;
      case 'trim':
        other = args[0]
        if (other) other = await other.literal()
        else other = 0
        let char = args[1]
        if (char) char = await char.literal()
        else char = ' '

        let esc_regx_char = (char) => char.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');

        let char_regx = esc_regx_char(char);

        switch (other) {
          case 1:
            result = me.replace(new RegExp(`^${char_regx}+`), '');
            break
          case 2:
            result = me.replace(new RegExp(`${char_regx}+$`), '');
            break
          case 0:
          default:
            result = me.replace(new RegExp(`^${char_regx}+|${char_regx}+$`, 'g'), '');
        }
        break;
      case 'length':
        result = me.length;
        break;
      case 'is_empty':
        result = !!me;
        breakl
      case 'is_blank':
        result = !!me.trim()
        break;
      case 'is_numeric':
        result = !!me && !isNaN(Number(me))
        break;
      case "endswith":
        result = me.endsWith(await args[0].literal())
        break;
      case "startswith":
        result = me.startsWith(await args[0].literal())
        break;
      case 'padend':
        result = me.padEnd(await args[0].literal(), await args[1].literal())
        break;
      case 'padstart':
        result = me.padStart(await args[0].literal(), await args[1].literal())
        break;
      case 'count':
        other = await args[0].literal()

        let count = 0;
        let position = 0;

        while ((position = me.indexOf(other, position)) !== -1) {
          count++;
          position += other.length;
        }
        result = count;
        break;
      case 'reverse':
        result = me.split('').reverse().join('');
        break
      case 'repeat':
        result = me.repeat(await args[0].literal())
        break
      case 'replace':
        let gl = args[2] && await args[2].literal(),
        su = await args[0].literal(), rpl = await args[1].literal()
        result = me.replace(su, rpl)
        if (gl){
          while(result.includes(su)) result = result.replace(su, rpl)
        }
        break
      case "split":
        break;
      case 'charcode':
        break;

    }

    return result;
  }
}

export default Str;