godprotocol 1.1.32 → 1.2.0

package/Datatypes/str.js

@@ -1,138 +1,204 @@
-import Storage from "./functions/storage";
+import Storage from "./functions/storage.js";
 
 class Str extends Storage {
-  constructor(config, manager) {
-    super(manager)
+  constructor(config, account) {
+    super(account)
 
     this.config = config
     this.type = 'string'
+
+    this.methods = {
+      ...this.methods,
+       
+      'title': {args: [], ret: ['Titled', 'string']},
+      'upper': {args: [], ret: ['CAPS', 'string']},
+      'lower': {args: [], ret: ['lower', 'string']},
+      'len': {args: [], ret: ['str.length', 'number']}, 
+      'slice': {args: [['start', 'number'], ['end', 'number']], ret: ['substr', 'string']}, 
+      'concat': {args: [['other', 'string']], ret: ['concatenated_str', 'string']}, 
+      'includes': {args: [['other', 'string']], ret: ['yes', 'boolean']}, 
+      'is_empty': {args: [], ret: ['yes', 'boolean']}, 
+      'is_blank': {args: [], ret: ['yes', 'boolean']}, 
+      'is_numeric': {args: [], ret: ['yes', 'boolean']}, 
+      'endswith': {args: [['char', 'string']], ret: ['yes', 'boolean']}, 
+      'startswith': {args: [['char', 'string']], ret: ['yes', 'boolean']}, 
+      'padend': {args: [['length', 'number'], ['char', 'string']], ret: ['result', 'string']}, 
+      'padstart': {args: [['length', 'number'], ['char', 'string']], ret: ['result', 'string']},
+      'count': {args: [['char', 'string']], ret: ['result', 'number']}, 
+      'reverse': {args: [], ret: ['reversed_string', 'string']}, 
+      'repeat': {args: [['count', 'number']], ret: ['repeated', 'string']}, 
+      'replace': {args: [['searchterm', 'string'], ['replacement', 'string'], ['globally', 'boolean']], ret: ['result', 'string']}, 
+      'charcode': {args: [['code', 'string']], ret: ['result', 'array']}, 
+      'find': {args: [['char', 'string'], ['last', 'boolean']], ret: ['index', 'number']}, 
+      'index': {args: [['index', 'number']], ret: ['char', 'string']}, 
+      'split': {args: [['char', 'string']], ret: ['result', 'array']}, 
+      'trim': {args: [['type', 'number', '0:boundaries', '1:beginning', '2:end'], ['char', 'string']], ret: ['result', '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())
+  title = async()=>{
+    let result = "";
+    this.value.split(' ').map(m=>{
+      result = `${result} ${m[0].toUpperCase()}${m.slice(1).toLowerCase()}`.trim()
+    })
+    return result
+  }
+
+  upper = ()=>{
+    return this.value.toUpperCase()
+  }
+
+  lower = ()=>{
+    return this.value.toLowerCase()
+  }
+
+  len = ()=> this.value.length
+
+  slice = async(start, args)=>{
+    let end
+    if(args.length > 1){
+      end = await args[1].literal()
+    }
+    return this.value.slice(start, end)
+  }
+
+  concat = (other)=>{
+    return `${this.value}${other}`
+  }
+
+  find = (other, args)=>{
+    let lst;
+    if (args.length>1){
+      lst = true;
+    }
+    return this.value[lst? 'lastIndexOf':'indexOf'](other)
+  }
+
+  includes = (other)=>this.value.includes(other)
+
+  index = other=>{
+    let result;
+    if (other < 0){
+      result = this.config.value.slice(other)[0]
+    }else result = this.config.value[other]
+
+    return result;
+  }
+
+  trim = async (other, args)=>{
+    let char;
+    if (args.length > 1){
+      char = await args[1].literal()
+    }else char = ' '
+
+    let esc_regx_char = (char) => char.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+    let char_regx = esc_regx_char(char), result;
+
+    switch (other) {
+      case 1:
+        result = this.value.replace(new RegExp(`^${char_regx}+`), '');
         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)
-        }
+      case 2:
+        result = this.value.replace(new RegExp(`${char_regx}+$`), '');
         break
-      case "split":
-        break;
-      case 'charcode':
-        break;
+      case 0:
+      default:
+        result = this.value.replace(new RegExp(`^${char_regx}+|${char_regx}+$`, 'g'), '');
+    }
+
+    return result
+  }
+
+  is_empty = ()=>{
+    return !!!this.value
+  }
+
+  is_blank = ()=>{
+    return !!!this.value.trim()
+  }
 
+  is_numeric = ()=>{
+    return !!this.value && !isNaN(Number(this.value))
+  }
+
+  endswith = other=>{
+    return this.value.endsWith(other)
+  }
+
+  startswith = other=>{
+    return this.value.startsWith(other)
+  }
+
+  padend = async (other, args)=>{
+    let char = await args[1].literal()
+
+    return this.value.padEnd(other, char)
+  }
+
+  padstart = async (other, args)=>{
+    let char = await args[1].literal()
+
+    return this.value.padStart(other, char)
+  }
+
+  count = (other)=>{
+    let count = 0;
+    let position = 0, result;
+
+    while ((position = this.value.indexOf(other, position)) !== -1) {
+      count++;
+      position += other.length;
     }
+    result = count;
 
-    return result;
+    return result
+  }
+
+  reverse = ()=>{
+    return this.value.split('').reverse().join('')
   }
+
+  repeat = (count)=>{
+    return this.value.repeat(count)
+  }
+
+  replace = async(search_term, args)=>{
+    let globally = args[2], replacement = args[1] && await args[1].literal(), result;
+
+    result = this.value.replace(search_term, replacement)
+    if (globally){
+      while(result.includes(search_term)) result = result.replace(search_term, replacement)
+    }
+  
+    return result
+  }
+
+  charcode = async(other)=>{
+    let code = other || "ascii", result;
+    let me = await this.literal()
+    if (code === "ascii") {
+      result = me.split("").map((char) => char.charCodeAt(0));
+    }
+
+    console.log(result, 'uh')
+    return result
+  }
+
+  split = async(other)=>{
+    let char = other || ''
+    let val = await this.literal();
+
+    let res =  val.split(char)
+    console.log(res)
+
+    return res;
+  }
+
+  literal = async()=>{
+    return this.config.value
+  }
+
 }
 
 export default Str;