vox-core

vox-core

NOTA : Este módulo está en etapa de prueba y está sujeto a cambios antes de su versión release. Por favor no use este módulo aún

---

vox-core es un módulo que permite ejecutar aplicaciones multiplataforma. vox-core se ejecuta sobre jxcore una versión de NodeJs que se puede ejecutar sobre plataformas móviles

vox-core es por así decirlo, un conjunto de módulos y código fuente listo para usar en sus proyectos. vox-core se podrá ejecutar sobre plataformas móviles como Android y iOs

Instalación vox-core

Primero instale jxcore. En Windows debe habilitar la opción añadir a variable PATH en la instalación

En Windows abra una consola (cmd) como usuario administrador y ejecute

> $ jx install -g vox-core

En sistemas Unix deberá usar sudo

> $ sudo jx install -g vox-core

Características de vox-core

Namespace al estilo .NET

Todos los módulos se pueden usar como namespaces, y clases dentro de la variable global core

Ejemplo para acceder a las clases de Globalization se usaría

core.System.Globalization

Globalización

Se usa similar a .NET. En cuanto a calendarios solo se ha implementado calendario gregoriano. Se puede acceder a las funciones de globalización mediante:

core.System.Globalization

Decimal

Tipo de dato funcionalmente igual a System.Decimal de .NET, excepto porque la representación del número en bytes no es igual a .NET

Decimal representa un número entero o decimal de hasta 29 dígitos significativos

Ejemplo de uso:

var num= new core.System.Decimal("12345678901234567890123456789")
var num2= num.div("123456")
var num3= num2.mul(new core.System.Decimal("1.343545345"))

Int64, UInt64

Tipo de datos número entero de 64 bits, completamente compatible con .NET System.Int64 o System.UInt64

Int64 > Número con signo UInt64 > Número sin signo

Permite realizar operaciones BitShift tomando los 64 bits, a diferencia de JavaScript, nativamente solo soporta estas operaciones como números de 32 bits

En vox-core Int64 y UInt64 utiliza bn.js, pero añade control de desbordamiento para permitir solo números de 64 bits, y las funciones para pasar a Buffer son diferentes en el caso de UInt64

Ejemplo de uso:

var num = core.System.Int64.maxValue
var num2= core.System.Int64.minValue
var num3= core.System.UInt64.maxValue
var num4= core.System.UInt64.minValue

// Resta
num.sub(num2)
// Suma
num.add(new Int64(1))

// Multiplicación
num.mul(new Int64(12000))
// División
num.div(new Int64(12000))

// Operación shift right
num.shiftRight(32)
// Operación shift left
num.shiftLeft(32)

System.IO

Al igual que el namespace System.IO de .NET, vox-core añade varias clases útiles como las de .NET

• BinaryReader
• BinaryWriter
• FileAccess
• FileMode
• FileNotFoundException
• FileStream
• IOException
• MemoryStream
• PathTooLongException
• SeekOrigin
• Stream

Los que estén familiarizados con estas clases en .NET podrán usarlas también en vox-core. Para acceder a este namespace:

core.System.IO

System.IEnum

En .NET se manejan las enumeraciones, en vox-core también. Es fácil crear las enumeraciones, y los valores dentro de las enumeraciones se pueden usar como números también. Piense en este ejemplo:

var DayOfWeek= System.IEnum.create("System.DayOfWeek",{
	"Sunday":0,
	"Monday":1,
	"Tuesday":2,
	"Wednesday":3,
	"Thursday":4,
	"Friday":5,
	"Saturday":6
});
DayOfWeek.Monday == 1; // true (es correcto)
DayOfWeek.Monday.toString(); // Monday

System.DateTime

Compatible con System.DateTime de .NET. Posee los mismos constructores y varios de sus métodos

var d= core.System.DateTime.now;
d.addMonths(1); 
d.addDays(1);
d.addYears(1);
d.addTicks(new core.System.Int64("982304022834893"))
d.ticks;

Microsoft.Win32.Registry

Namespace similar a Microsoft.Win32.Registry de .NET. La diferencia es que en vox-core los métodos son asíncronos, y por eso tienen el sufijo Async

// Cuando se utiliza este namespace como este que es asíncrono debe ir la siguiente línea
await core.Microsoft.Win32.Registry.ready();

var key= await core.Microsoft.Win32.Registry.localMachine.openSubKeyAsync("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run",true)

// SetValue
await key.setValueAsync(conf.id, value);

System.Text.Encoding

Compatible con el namespace de .NET System.Text.Encoding. Por ahora soporta los mismos códecs de iconv-lite

core.System.Text.Encoding.UTF8;
core.System.Text.Encoding.ascii;
core.System.Text.Encoding.unicode;

// Utilizando constructor y pasando cualquiera de las codificaciones soportadas
var enc= new core.System.Text.Encoding("utf16");

Ecma2015 Parser

Puede analizar código Ecma2015 y Async/Await de EcmaScript 7 y devuelve el ast y código transformado a EcmaScript2015

var parser= new core.VW.Ecma2015.Parser()
var resultado= parser.parse("class Person{ move(){return 3;} }")

// Resultado de parse
resultado.code;
resultado.ast;

vox-core permite usar código Ecma6 y Async/Await automáticamente si su archivo posee la extensión .es6

Clr

Función disponible en Windows, con .NET Framework 4.0 y en sistemas Unix con Mono

Permite ejecutar código y utilizar cualquier clase del NET Framework desde vox-core. Este módulo es utilizado en Microsoft.Win32.Registry.

Así sería el ejemplo mostrado en Microsoft.Win32.Registry usando solo Clr

var Clr= new core.VW.Clr.Manager()

// Esto solo carga el tipo y los métodos y propiedades que se van a usar, aún no ejecuta código Clr
var RegistryClass= Clr.get("Microsoft.Win32.Registry").property("LocalMachine")

var RegistryKeyClass= Clr.get("Microsoft.Win32.RegistryKey").method("OpenSubKey", "SetValue")

var key= await RegistryClass.get_LocalMachine()

key= await key.openSubKey("SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run",true)

// SetValue
await key.setValue(conf.id, value);

E6Html

E6Html es un formato de archivo diseñado por VoxSoftware principalmente para servidores, donde se coloca código HTML junto con código que se ejecuta desde el servidor.

Para usar E6Html puede obtener archivos compilados y ejecutar bajo un contexto:

var file= core.VW.E6Html.E6Html(path)
file.compile()

// Al ejecutar invoke, si no se envía el argumento context, se utiliza ConsoleContext el cual escribe a la consola la salida

file.invoke(/* optional context */)

También puede crear un servidor HTTP, y automáticamente se leerá e interpretará estos archivos:

var init= async function (){
	var path= "./server-files"
	var server= new core.VW.E6Html.Http.Server()
	server.timeout=5000
	server.port= 900
	server.path= path
	await server.listen()
	vw.log("Servicio disponible: ", server.port)
	while(true){
		var reqArgs= await server.acceptAsync()
		procesar(reqArgs);
	}
}

var procesar= async function(req){
	try{
		await req.catch(req.continue)
	}
	catch(e){
		try{
			req.response.statusCode=500
			try{
				req.response.write( JSON.stringify({
					error:e.stack
				},4,'\t'));
			}catch(ex){
			}
			req.response.end()
		}
		catch(ex){}
		console.error(e);
	}
}
init();

**Formato E6HTML **

• vw-expression > El contenido se evalúa como una expresión y se escapa los caracteres. Ejemplo:

<vw-expression>process.pid</vw-expression>

• vw-rawexpression > El contenido se evalúa como una expresión pero su contenido no es escapado. Ejemplo:

<vw-rawexpression>funcionquedevuelvehtml()</vw-rawexpression>

• vw-base64 > El contenido se toma como un string codificado en base64. Ejemplo:

<title><vw-base64>dm94LWNvcmU=</vw-base64></title>

esto es equivalente a

<title>vox-core</title>

• vw-base64-expression > El contenido se toma como una expresión que se evalúa y se toma como un string codificado en base64. Ejemplo:

<title><vw-base64-expression>base64Expr</vw-base64></title>

• **Sintáxis {{ expression }} ** > Se puede utilizar {{ y }} para encerrar expresiones, que son reemplazadas al renderizar el archivo. Por ejemplo suponiendo que se tiene una variable global title

<div title="{{title}}"></div>

• **script (server-side) ** > Mediante las etiquetas script de HTML y añadiendo el atributo server-side, se indica que este código se ejecuta del lado servidor. También se puede utilizar el atributo async para indicar que el código usa async/await de EcmaScript 7

<script server-side>
var name=''
</script>

<script server-side async>
async function(){
	var key= await core.Microsoft.Win32.Registry.localMachine.openSubKeyAsync(key)
	name= key.getValueAsync("") 
}
</script>

<div class='name'><vw-expression>name</vw-expression></div>

Licencia

MIT License