VJS

V bindings to QuickJS javascript engine. Run JS in V.

Features

• Evaluate js (code, file, module, etc).
• Multi evaluate support.
• Callback function support.
• Set-Globals support.
• Set-Module support.
• Call V from JS.
• Call JS from V.
• Top-Level await support. using vjs.type_module.

Install

v install herudi.vjs

Basic Usage

Create file main.v and copy-paste this code.

import herudi.vjs

fn main() {
  rt := vjs.new_runtime()
  ctx := rt.new_context()

  value := ctx.eval('1 + 2') or { panic(err) }
  ctx.end()

  assert value.is_number() == true
  assert value.is_string() == false
  assert value.to_int() == 3

  println(value)
  // 3

  // free
  value.free()
  ctx.free()
  rt.free()
}

Run

v run main.v

Explore examples

Currently support linux/mac/win (x64).

in windows, requires -cc gcc.

Multi Evaluate

ctx.eval('const sum = (a, b) => a + b') or { panic(err) }
ctx.eval('const mul = (a, b) => a * b') or { panic(err) }

sum := ctx.eval('sum(${1}, ${2})') or { panic(err) }
mul := ctx.eval('mul(${1}, ${2})') or { panic(err) }

ctx.end()

println(sum)
// 3

println(mul)
// 2

Add Global

glob := ctx.js_global()
glob.set('foo', 'bar')

value := ctx.eval('foo') or { panic(err) }
ctx.end()

println(value)
// bar

Add Module

mut mod := ctx.js_module('my-module')
mod.export('foo', 'foo')
mod.export('bar', 'bar')
mod.export_default(mod.to_object())
mod.create()

code := '
  import mod, { foo, bar } from "my-module";

  console.log(foo, bar);

  console.log(mod);
'

ctx.eval(code, vjs.type_module) or { panic(err) }
ctx.end()

Web Platform APIs

Inject Web API to vjs.

import herudi.vjs
import herudi.vjs.web

fn main() {
  rt := vjs.new_runtime()
  ctx := rt.new_context()

  // inject all
  web.inject(ctx)

  // or inject one by one
  // web.console_api(ctx)
  // web.encoding_api(ctx)
  // more..

  ...
}

List Web Platform APIs

• Console
• setTimeout,clearTimeout- [x] setInterval,clearInterval- [x] btoa,atob- [x] URL
• URLSearchParams
• URLPattern
• Encoding API
• TextEncoder
• TextDecoder
• TextEncoderStream
• TextDecoderStream
• Crypto API
• randomUUID
• getRandomValues
• SubtleCrypto
• digest
• encrypt
• decrypt
• sign
• verify
• Streams API
• FormData
• Blob
• File
• Performance
• Navigator
• Fetch API
• Fetch
• Headers
• Request
• Response
• More...

It's Fun Project. PRs Wellcome :)

fn new_runtime() Runtime

Create new Runtime.

rt := vjs.new_runtime()

type AnyValue = Value | bool | f64 | i64 | int | string | u32 | u64

type Anything Value in vjs

type AtomValue = int | string

type CallbackPromise = fn (Promise) Value

type Callback JS Promise.

type JSCFunction = fn (&C.JSContext, JSValueConst, int, &JSValueConst) C.JSValue

Original type JS Callback function from qjs

type JSConstructor = fn (this Value, args []Value)

type Constructor Class function

type JSFunction = fn (args []Value) Value

type JS Callback function

type JSFunctionThis = fn (this Value, args []Value) Value

type JS Callback function with this

type JSValueConst = C.JSValue

type JSValueConst. this type is free.

type PropKey = Atom | PropertyEnum | int | string

type property keys. to use get/set values.

enum JSPromiseStateEnum {
	pending
	resolved
	rejected
}

enum Promise State

struct Atom {
	ref C.JSAtom
	ctx Context
}

Atom structure based on JSAtom in qjs and implemented into ref.

fn (a Atom) to_string() string

Convert Atom to string.

fn (a Atom) str() string

Convert Atom to string.

fn (a Atom) to_value() Value

Convert Atom to Value.

val := atom.to_value()
println(val)

fn (a &Atom) free()

Free Atom

struct ClassParams {
	id   ?u32
	name string
	ctor ?JSConstructor
}

struct Context {
	ref &C.JSContext
	rt  Runtime
}

Context structure based on JSContext in qjs and implemented into ref.

fn (ctx &Context) any_to_val(val AnyValue) Value

Convert any to value.

fn (ctx &Context) call(val Value, args ...AnyValue) !Value

Callback from Context

fn (ctx &Context) call_this(this Value, val Value, args ...AnyValue) !Value

Callback this from Context

fn (ctx &Context) dump_error() Value

Dump std Error

fn (ctx &Context) dup_context() &Context

Duplicate context

fn (ctx &Context) end()

Context end

fn (ctx &Context) eval(args ...EvalArgs) !Value

Evaluate JS

val1 := ctx.eval('1 + 1')!

// or module
val2 := ctx.eval('1 + 1', vjs.type_module)!

fn (ctx &Context) eval_file(args ...EvalArgs) !Value

Evaluate File

ctx.eval_file('./path/to/file.js')!

// or module
ctx.eval_file('./path/to/file.js', vjs.type_module)!

fn (ctx &Context) eval_function(val Value) Value

Evaluate Function

fn (ctx &Context) eval_module(input string, fname string) !Value

Evaluate JS module

ctx.eval_module('1 + 1', 'index.js')!

fn (ctx &Context) free()

Free the context

fn (ctx &Context) js_array() Value

Create JS Array.

fn (ctx &Context) js_array_buffer(data []u8) Value

Create JS ArrayBuffer.

fn (ctx &Context) js_await(val Value) !Value

JS call await.

fn (ctx &Context) js_big_int(data i64) Value

Create JS Bigint.

fn (ctx &Context) js_big_uint(data u64) Value

Create JS Big Uint.

fn (ctx &Context) js_bool(data bool) Value

Create JS Boolean.

fn (ctx &Context) js_class(cls ClassParams) Value

Create JS Class

foo_class := ctx.js_class(
	 name: 'Foo',
	 ctor: fn (this Value, args []Value) {
		 // constructor code here
	 }
)

foo := foo_class.new()

fn (ctx &Context) js_dump(err IError) Value

js dump IError.

fn (ctx &Context) js_error(err JSError) Value

create JS new Error.

fn (ctx &Context) js_eval(input string, fname string, flag int) !Value

Evaluate JS with complete params

ctx.js_eval(code, filename, flag)!

fn (ctx &Context) js_eval_core(input &char, len usize, fname &char, flag int, from_file bool) !Value

Core evaluate JS

fn (ctx &Context) js_exception() &JSError

Create JS Exception.

if val.is_exception() {
  return ctx.js_exception()
}

fn (ctx &Context) js_float(data f64) Value

Create JS Float.

fn (ctx &Context) js_function(cb JSFunction) Value

JS Callback function

my_fn := ctx.js_function(fn [ctx](args []Value) Value {
  return ctx.js_string('foo')	
})

fn (ctx &Context) js_function_this(cb JSFunctionThis) Value

JS Callback function with this

my_fn := ctx.js_function_this(fn (this Value, args []Value) Value {
  return this.ctx.js_string('foo')	
})

fn (ctx &Context) js_global(keys ...string) Value

Define JS Global (globalThis).

fn (ctx &Context) js_i64(data i64) Value

Create JS int64.

fn (ctx &Context) js_int(data int) Value

Create JS Int.

fn (ctx &Context) js_module(name string) Module

Initial js_module.

mod := ctx.js_module('my-module')

fn (ctx &Context) js_new_class(val Value, args ...AnyValue) !Value

JS call new class.

fn (ctx &Context) js_null() Value

Create JS Null.

fn (ctx &Context) js_object() Value

Create JS Object.

fn (ctx &Context) js_only_function(cb JSFunction) JSCFunction

JS Callback only function

fn (ctx &Context) js_only_function_this(cb JSFunctionThis) JSCFunction

JS Callback only function this

fn (ctx &Context) js_promise() Promise

Same as new_promise, but without callback.

fn (ctx &Context) js_string(data string) Value

Create JS String.

fn (ctx &Context) js_throw(any AnyValue) Value

JS Throw Error.

fn (ctx &Context) js_type_error(err JSError) Value

create JS new TypeError.

fn (ctx &Context) js_u32(data u32) Value

Create JS u32.

fn (ctx &Context) js_undefined() Value

Create JS Undefined.

fn (ctx &Context) js_uninitialized() Value

Create JS Uninitialized.

fn (ctx &Context) json_parse(str string) Value

Convert value string to js_object.

fn (ctx &Context) json_stringify(val Value) string

Convert value js_object to json string.

fn (ctx &Context) json_stringify_op(val Value, rep Value, ind AnyValue) string

Convert value js_object to json string with optionals.

fn (ctx &Context) loop()

std loop form qjs

fn (ctx &Context) new_atom(val AtomValue) Atom

Create new Atom support int | string.

atom := ctx.new_atom('my_atom')

fn (ctx &Context) new_promise(cb CallbackPromise) Value

Create new Promise.

promise := ctx.new_promise(fn [ctx](p Promise) Value {
	 if err {
		 return p.reject(ctx.js_error(message: 'rejected'))
	 }
	 return p.resolve(ctx.js_string('resolved'))
})

value := promise.await()
println(value)

fn (ctx &Context) promise_result(val Value) Value

Get Promise Result

fn (ctx &Context) promise_state(val Value) Value

Get Promise State

fn (ctx &Context) runtime() Runtime

Get runtime from context

struct ContextConfig {
	unhandled_rejection bool = true
	bignum              bool = true
	module_std          bool
}

ContextConfig structure params.

struct JSError {
	Error
pub mut:
	name    string = 'Error'
	stack   string
	message string
}

JSError structure.

fn (err &JSError) msg() string

lookup/print JSError message.

struct Module {
	ctx  Context
	name string
mut:
	exports_str []string
	exports     []&char
	values      []Value
}

Module structure.

fn (mut m Module) export(name string, any AnyValue)

Export module.

mod.export('foo', 'bar')

fn (mut m Module) set(name string, any AnyValue)

Same as Export.

fn (mut m Module) get(name string) Value

Get value from export/set.

fn (mut m Module) to_object() Value

Convert module to JS object.

fn (mut m Module) export_default(any AnyValue)

Export default.

mod.export_default(mod.to_object())

fn (mut m Module) create() &C.JSModuleDef

Create module.

mod := ctx.js_module('my-module')
mod.export('foo', 'bar')
mod.export_default(mod.to_object())
mod.create()

struct Promise {
	ctx Context
}

Promise structure.

fn (p Promise) resolve(any AnyValue) Value

Promise resolve

fn (p Promise) reject(any AnyValue) Value

Promise reject

struct PropertyEnum {
pub:
	atom          Atom
	is_enumerable bool
}

PropertyEnum structure based on JSPropertyEnum in qjs.

struct Runtime {
	ref &C.JSRuntime
}

Runtime structure based on JSRuntime in qjs and implemented into ref.

fn (rt &Runtime) free()

Free runtime

fn (rt Runtime) is_job_pending() bool

Check if job is pending

fn (rt Runtime) new_context(config ContextConfig) &Context

Create new Context from Runtime.

rt := vjs.new_runtime()
ctx := rt.new_context(opts_config)

fn (rt Runtime) promise_rejection_tracker()

Promise rejection tracker (default true)

fn (rt Runtime) run_gc()

Run qjs garbage collector

fn (rt Runtime) set_gc_threshold(th i64)

Set gc threshold.

fn (rt Runtime) set_max_stack_size(stack_size u32)

Set maximum stack size. (default to 255)

fn (rt Runtime) set_memory_limit(limit u32)

Set limit memory. (default to unlimited)

struct Value {
	ref C.JSValue
pub:
	ctx Context
}

Value structure based on JSValue in qjs and implemented into ref.

fn (v Value) await() Value

Awaited from Promise

val := my_promise.await()

fn (v Value) byte_len() int

byteLength value

fn (v Value) call(key string, args ...AnyValue) Value

Call fn.

array.call('push', ...args)

fn (v Value) callback(args ...AnyValue) Value

Callback function self

val := my_fn.callback(...args)

fn (v Value) delete(key PropKey) bool

Delete property

obj.delete('foo')

fn (v Value) dup_value() Value

Duplicate value

fn (v &Value) free()

Free Value

fn (v Value) get(key PropKey) Value

Get property

foo := obj.get('foo')

fn (v Value) has(key PropKey) bool

Has property

has := obj.has('foo')

fn (v Value) instanceof(key string) bool

Check value with instanceof.

assert val.instanceof('Promise') == true

fn (v Value) is_array() bool

Check value is array.

fn (v Value) is_big_decimal() bool

Check value is big decimal.

fn (v Value) is_big_float() bool

Check value is bigfloat.

fn (v Value) is_big_int() bool

Check value is bigint.

fn (v Value) is_bool() bool

Check value is boolean.

fn (v Value) is_error() bool

Check value is error.

fn (v Value) is_exception() bool

Check value is exception.

fn (v Value) is_function() bool

Check value is function.

fn (v Value) is_null() bool

Check value is null.

fn (v Value) is_number() bool

Check value is number.

fn (v Value) is_object() bool

Check value is object.

fn (v Value) is_string() bool

Check value is string.

fn (v Value) is_symbol() bool

Check value is symbol.

fn (v Value) is_undefined() bool

Check value is undefined.

fn (v Value) is_uninitialized() bool

Check value is uninitialized.

fn (v Value) json_stringify() string

Convert Value object to V string json

fn (v Value) len() int

Length value

fn (v Value) new(args ...AnyValue) Value

New from classes

val := my_class.new(...args)

fn (v Value) property_names() ![]PropertyEnum

arrays property_names []PropertyEnum.

props := val.property_names() or { panic(err) }
println(props)

for prop in props {
  println(prop.atom)
	 println(prop.is_enumerable)
}

fn (v Value) set(key PropKey, any AnyValue)

Set property

obj := ctx.js_object()
obj.set('foo', 'foo')

fn (v Value) str() string

Convert Value to V String

fn (v Value) to_bool() bool

Convert Value to V bool

fn (v Value) to_bytes() []u8

Convert Value to V []u8

fn (v Value) to_error() &JSError

Convert Value to V JSError

fn (v Value) to_f64() f64

Convert Value to V f64

fn (v Value) to_i64() i64

Convert Value to V i64

fn (v Value) to_int() int

Convert Value to V int

fn (v Value) to_string() string

Convert Value to V String

fn (v Value) to_u32() u32

Convert Value to V u32

fn (v Value) typeof_name() string

Check typeof name value.