godprotocol 1.1.0 → 1.1.2

package/Executables/functions/adminstrator/adm_register.js

@@ -1,29 +0,0 @@
-import { render } from "./render";
-import native_components, { natives } from "./native_components";
-
-const adm_register = (account)=>{
-  let add_callable = account.vm.add_callable;
-
-  add_callable('render', {
-    callable:render,
-    config: {
-      parameters:[
-        {name:'object', position:0}
-      ]
-    }
-  })
-  
-  natives.map(name=>{
-    add_callable(name, {
-      callable:(args, vm, options)=>native_components(args, vm, {...options, name}),
-      config: {
-        parameters:[
-          {name:'props', position:0}
-        ]
-      }
-    })
-  })
-
-}
-
-export default adm_register;

package/Executables/functions/adminstrator/native_components.js

@@ -1,10 +0,0 @@
-let natives = ['Div', 'Text']
-
-const native_components = (args, vm, options)=>{
-  let {props} = args;
-
-  vm.write_chain(props, options.location)
-}
-
-export default native_components
-export {natives}

package/Executables/functions/adminstrator/query_selectors.js

@@ -1,10 +0,0 @@
-const get_element = (args, vm, options)=>{
-
-}
-
-const set_element = (args, vm, options)=>{
-  
-}
-
-
-export {get_element, set_element}

package/Executables/functions/adminstrator/render.js

@@ -1,24 +0,0 @@
-const render = (args, vm, options) => {
-  let {object, page} = args;
-
-  if (!object.render){
-    return vm.stderr({name:'Name_error', message:"A render method is neccessary for Adm display"})
-  }
-
-  let config = vm.read_chain(object.config)
-  config = vm.display(config);
-
-  console.log(config)
-  
-  vm.exec({executable: object.render, location: result=>{
-    let raw = vm.display(result, {include_address:true})
-
-    raw.address = object.__address__
-    raw.page = page;
-    
-    vm.air_object(raw, options)
-  }})
-  
-}
-
-export {render}

package/Executables/functions/array_register.js

@@ -1,161 +0,0 @@
-import {  concat, repeat, slice, pop, index, clear, insert,  replace, map, find, copy, filter } from "./methods/array";
-
-const array_register = (account)=>{
-  let add_callable = account.vm.add_callable;
-
-  add_callable('insert_', {
-    callable: insert,
-    config: {
-      parameters: [
-        {name:'arr', position:0},
-        {name:'value', position:1},
-        {name:'index', position:2},
-      ]
-    }
-  })
-
-  add_callable('arr_slice_', {
-    callable: slice,
-    config: {
-      parameters: [
-        {name:'arr', position:0},
-        {name:'start', position:1},
-        {name:'end', position:2},
-      ]
-    }
-  })
-
-  add_callable('arr_concat_', {
-    callable: concat,
-    config: {
-      parameters: [
-        {name:'arr', position:0},
-        {name:'other', position:1},
-        {name:'index', position:2},
-      ]
-    }
-  })
-
-  add_callable('extend_',{
-    callable: (args, vm, options) => concat(args, vm, {...options, spread:true}),
-    config: {
-      parameters: [
-        {name:'arr', position:0},
-        {name:'other', position:1},
-        {name:'index', position:2},
-      ]
-    }
-  })
-
-  add_callable('index_', {
-    callable: index,
-    config: {
-      parameters: [
-        {name:'arr', position:0},
-        {name:'n', position:1},
-      ]
-    }
-  })
-
-  add_callable('pop_', {
-    callable: pop,
-    config: {
-      parameters: [
-        {name:'arr', position:0},
-        {name:'index', position:1},
-      ]
-    }
-  })
-
-  add_callable('replace_', {
-    callable: replace,
-    config: {
-      parameters: [
-        {name:'arr', position:0},
-        {name:'index', position:1},
-        {name:'value', position:1},
-      ]
-    }
-  })
-
-
-  add_callable('repeat_', {
-    callable: repeat,
-    config: {
-      parameters: [
-        {name: 'arr', position:0},
-        {name: 'n', position:1},
-      ]
-    }
-  })
-
-  add_callable('clear_', {
-    callable: clear,
-    config: {
-      parameters: [
-        {name: 'arr', position:0},
-      ]
-    }
-  })
-
-  add_callable('findindex_', {
-    callable:(args, vm, options)=> find(args, vm, {...options, index: true}),
-    config: {
-      parameters: [
-        {name: 'arr', position:0},
-        {name: 'executable', position:1},
-      ]
-    }
-  })
-
-  add_callable('map_', {
-    callable: map,
-    config: {
-      parameters: [
-        {name: 'arr', position:0},
-        {name: 'executable', position:1},
-      ]
-    }
-  })
-
-  add_callable('find_', {
-    callable: find,
-    config: {
-      parameters: [
-        {name: 'arr', position:0},
-        {name: 'executable', position:1},
-      ]
-    }
-  })
-
-  add_callable('filter_', {
-    callable: filter,
-    config: {
-      parameters: [
-        {name:'arr', position:0},
-        {name:'executable', position:1},
-      ]
-    }
-  })
-
-  add_callable('copy_', {
-    callable: copy,
-    config: {
-      parameters: [
-        {name:'arr', position:0},
-      ]
-    }
-  })
-
-  add_callable('deepcopy_', {
-    callable: (args, vm, options)=>copy(args, vm, {...options, deep:true}),
-    config: {
-      parameters: [
-        {name:'arr', position:0},
-        {name:'depth', position:1},
-      ]
-    }
-  })
-}
-
-export default array_register

package/Executables/functions/assign.js

@@ -1,19 +0,0 @@
-const assign = (args, vm, options)=>{
-  let {location, arguments: argg} = options;
-  let {value} = args;
-
-  let value_addr = argg.argv[0].address;
-  let value_chain = vm.handle_chain(value_addr);
-
-  let loc_chain = vm.handle_chain(location)
-  if(value_chain.datapath){
-    loc_chain.set_obj_config(value_chain.datapath)
-  }else {
-    
-    loc_chain.forge_block({metadata:{output: vm.account.save(value)}})
-    loc_chain.set_obj_config('')
-  }
-}
-
-
-export default assign

package/Executables/functions/display.js

@@ -1,55 +0,0 @@
-const display = (args, vm, options) => {
-  let { data } = args;
-
-  // console.log(args, 'display.args')
-  if (!Array.isArray(data)) data = [data];
-
-
-  if (options.metadata && options.metadata.raw){
-    return vm.display(vm.static_value(data[0]))
-  }
-
-  let val = new Array(data.length),
-    d = 0;
-
-  for (d = 0; d < data.length; d++) {
-    let dat = data[d];
-
-    if(!dat){continue}
-    if (dat.static_value) {
-      val[d] = dat.static_value;
-    } else if (dat.__print__) {
-      vm.exec({
-        executable: dat.__print__,
-        metadata: { index: d },
-        location: (result, metadata) => {
-          if (result.__print__) {
-            result = vm.static_value(result, true);
-            if (!result) {
-              this.stderr({
-                name: "Type_error",
-                message: `class.__print__ must return one of type boolean | string | number | twain | array | void`,
-              });
-            }
-          }
-          val[metadata.index] = result;
-
-          if (val.filter((v) => !!v).length === data.length) {
-            vm.display(val)
-          }
-        },
-      });
-    } else {
-      val[d] = JSON.stringify(dat);
-    }
-  }
-
-  if (val.filter((v) => !!v).length === data.length) {
-    vm.display(val)
-  }
-
-  if (options.metadata && options.metadata.raw)
-    return JSON.parse(val[0])
-};
-
-export { display };

package/Executables/functions/folder.js

@@ -1,95 +0,0 @@
-const readone = (args, vm, options) =>{
-  let {query} = args;
-
-  let {fold} = clean_check_folder(args, vm)
-
-  vm.display(query, (res)=>{
-    vm.air_object(fold.readone(res), options)
-  })
-}
-
-const read = (args, vm, options) =>{
-  let {query} = args;
-
-  let {fold} = clean_check_folder(args, vm)
-
-  vm.display(query, (res)=>{
-    vm.air_object(fold.read(res), options)
-  })
-}
-
-const clean_check_folder = (args, vm)=>{
-  let {folder}= args;
-
-  let name = vm.read_chain(folder.name)
-  if(name.__classifier__ !== vm.get_type_address('string')){
-    return vm.stderr({name:'Type_error', message: "Folder name must be a string."})
-  }else name = vm.static_value(name);
-
-  let fold = vm.account.manager.oracle.gds.folder(name.static_value)
-
-  return {name, fold}
-}
-
-const write = (args, vm, options) =>{
-  let {data} = args;
-
-  let {fold} = clean_check_folder(args, vm)
-  
-  vm.display(data, (res)=>{
-    vm.air_object(fold.write(res), options)
-  })
-}
-
-const write_several = (args, vm, options) =>{
-  let {data} = args;
-
-  let {fold} = clean_check_folder(args, vm)
-
-  vm.display(data, (res)=>{
-    vm.air_object(fold.write_several(res), options)
-  })
-}
-
-
-const remove = (args, vm, options) =>{
-  let {query} = args;
-
-  let {fold} = clean_check_folder(args, vm)
-
-  vm.display(query, (res)=>{
-    vm.air_object(fold.remove(res), options)
-  })
-}
-
-const remove_several = (args, vm, options) =>{
-  let {query} = args;
-
-  let {fold} = clean_check_folder(args, vm)
-
-  vm.display(query, (res)=>{
-    vm.air_object(fold.remove_several(res), options)
-  })
-}
-
-const update = (args, vm, options) =>{
-  let {query} = args;
-
-  let {fold} = clean_check_folder(args, vm)
-
-  vm.display(query, (res)=>{
-    vm.air_object(fold.update(res), options)
-  })
-}
-
-const update_several = (args, vm, options) =>{
-  let {query} = args;
-
-  let {fold} = clean_check_folder(args, vm)
-
-  vm.display(query, (res)=>{
-    vm.air_object(fold.update_several(res), options)
-  })
-}
-
-export {read, readone, update, update_several, write, write_several, remove, remove_several}

package/Executables/functions/folder_register.js

@@ -1,87 +0,0 @@
-import { read, readone, remove, remove_several, update, update_several, write, write_several } from "./folder";
-
-const folder_register = (account)=>{
-  let add_callable = account.vm.add_callable;
-
-  add_callable('read_', {
-    callable: read,
-    config: {
-      parameters: [
-        {name:'folder', position:0},
-        {name:'query', position:1},
-      ]
-    }
-  })
-
-  add_callable('readone_', {
-    callable: readone,
-    config: {
-      parameters: [
-        {name:'folder', position:0},
-        {name:'query', position:1},
-      ]
-    }
-  })
-
-  add_callable('update_', {
-    callable: update,
-    config: {
-      parameters: [
-        {name:'folder', position:0},
-        {name:'query', position:1},
-      ]
-    }
-  })
-
-  add_callable('update_several_', {
-    callable: update_several,
-    config: {
-      parameters: [
-        {name:'folder', position:0},
-        {name:'query', position:1},
-      ]
-    }
-  })
-
-  add_callable('write_several_', {
-    callable: write_several,
-    config: {
-      parameters: [
-        {name:'folder', position:0},
-        {name:'data', position:1},
-      ]
-    }
-  })
-
-  add_callable('write', {
-    callable: write,
-    config: {
-      parameters: [
-        {name:'folder', position:0},
-        {name:'data', position:1},
-      ]
-    }
-  })
-
-  add_callable('remove_several_', {
-    callable: remove_several,
-    config: {
-      parameters: [
-        {name:'folder', position:0},
-        {name:'query', position:1},
-      ]
-    }
-  })
-
-  add_callable('remove', {
-    callable: remove,
-    config: {
-      parameters: [
-        {name:'folder', position:0},
-        {name:'query', position:1},
-      ]
-    }
-  })
-}
-
-export default folder_register

package/Executables/functions/importcheck.js

@@ -1,13 +0,0 @@
-const importcheck = (args, vm)=>{
-  console.log(args, 'importcheck.args')
-  let {names} = args;
-
-  if(!Array.isArray(names)) names = [names]
-
-  for (let n=0; n< names.length; n++){
-    let name = names[n]
-
-  }
-}
-
-export default importcheck

package/Executables/functions/indices.js

@@ -1,56 +0,0 @@
-
-
-const get = (args, vm, options)=>{
-  let{obj,prop}=args;
-
-  // console.log(args, 'get args')
-  if(!obj||!prop) return vm.stderr(`Invalid arguments in get.callable`)
-
-  if (obj.__classifier__ === vm.get_type_address('twain')){
-    let get_ = require('./methods/twain').get
-    return get_({twain: obj, prop}, vm, options)
-  }
-  prop = vm.static_value(prop)
-
-  if (prop.__print__){
-    vm.exec({executable: prop.__print__, location: (prop)=>{
-      
-      if(!prop.static_value)return this.stderr({name:'Type_error', message: "get.callables"})
- 
-      let addr = obj[prop.static_value]
-      let result = vm.read_chain(addr)
-
-      vm.write_chain(result, options.location)
-      
-    }})
-  
-    return;
-  }
-  
-  let static_prop = prop.static_value
-  let addr = obj[static_prop]
-  let result = vm.read_chain(addr)
-
-  return {result, is_callable: !!(result.__address__ && vm.handle_chain(result.__address__).datapath)}
-}
-
-const set = (args, vm)=>{
-  let {obj, prop, value} = args;
-
-  // console.log(args, 'set args')
-  if(!obj || !prop || !value) return vm.stderr(`Invalid arguments in set.callable`)
-  
-  prop = vm.static_value(prop)
-  
-  let static_prop = prop.static_value
-  let val_addr = value.__address__
-  obj[static_prop] = val_addr;
-
-  vm.write_chain(obj, obj.__address__, {is_callable: !!vm.handle_chain(value.__address__).datapath})
-
-  return {
-    result: obj,
-  }
-}
-
-export {get, set}

package/Executables/functions/len.js

@@ -1,22 +0,0 @@
-const len = (args, vm, options) => {
-  let {object} = args;
-
-  if(![vm.get_type_address('string'),vm.get_type_address('array')].includes(object.__classifier__)){
-    if (object.__len__){
-      vm.exec({executable: object.__len__, location: result=>{
-        if (result.__classifier__ !== vm.get_type_address('number')){
-          return vm.stderr({name:'Type_error', message: `__len__ method should only return type of 'number'`})
-        }
-        
-        vm.write_chain(result, options.location)
-      }})
-    }else return vm.air_object(null, options)
-  }
-
-  let statics = vm.static_value(object)
-
-  vm.air_object(statics.static_value.length, options)
-}
-
-
-export default len