NagaeJSVM/ngjsvm/js_export.go

package ngjsvm

import (
	"git.swzry.com/zry/GoHiedaLogger/hiedalog"
	"github.com/dop251/goja"
	"github.com/dop251/goja_nodejs/require"
	"sync"
)

type JSEnv struct {
	jsvm          *JSVM
	logger        *hiedalog.HiedaLogger
	logPrefix     string
	rtRumtimes    map[string]JsRtInterface
	mapLock       sync.RWMutex
	registry      *require.Registry
	requireModule *require.RequireModule
}

type JsRtInterface interface {
	RegisterRt(name string, env *JSEnv) (goja.Value, error)
	IsRegistered() bool
	Dispose()
}

func NewJSEnv(vm *JSVM, logger *hiedalog.HiedaLogger, logPrefix string) *JSEnv {
	je := &JSEnv{
		jsvm:       vm,
		logger:     logger,
		logPrefix:  logPrefix,
		rtRumtimes: make(map[string]JsRtInterface),
		mapLock:    sync.RWMutex{},
	}
	je.registry = require.NewRegistryWithLoader(je.registryLoader)
	je.prepareBasicJsEnv()
	return je
}

func (v *JSEnv) EnableRegistry(gojaVM *goja.Runtime) {
	v.requireModule = v.registry.Enable(gojaVM)
}

func (v *JSEnv) registryLoader(path string) ([]byte, error) {
	return v.jsvm.RegistryLoaderFunc(path)
}

func (v *JSEnv) AddRt(name string, newJSRt JsRtInterface) {
	if newJSRt == nil {
		v.logger.LogPrintf(v.logPrefix, hiedalog.DLN_WARN, "register a nil Rt '%s'", name)
		return
	}
	if newJSRt.IsRegistered() {
		v.logger.LogPrintf(v.logPrefix, hiedalog.DLN_VERBOSE, "register a Rt '%s' which is already registered. Ignored.", name)
		return
	}
	v.mapLock.Lock()
	defer v.mapLock.Unlock()
	_, exists := v.rtRumtimes[name]
	if exists {
		v.logger.LogPrintf(v.logPrefix, hiedalog.DLN_VERBOSE, "register a Rt '%s' that there is one already registered with this name. Ignored.", name)
		return
	}
	obj, err := newJSRt.RegisterRt(name, v)
	if err != nil {
		v.logger.LogPrintf(v.logPrefix, hiedalog.DLN_WARN, "register Rt '%s' failed: RegisterRt: %v", name, err)
		return
	}
	err = v.jsvm.RegisterObject(name, obj)
	if err != nil {
		newJSRt.Dispose()
		v.logger.LogPrintf(v.logPrefix, hiedalog.DLN_WARN, "register Rt '%s' failed: VM.RegisterObject: %v", name, err)
		return
	}
	v.rtRumtimes[name] = newJSRt
}

func (v *JSEnv) JSCallQuit() {
	v.jsvm.JSCallQuit()
}

func (v *JSEnv) EnvDispose() {
	v.mapLock.Lock()
	defer v.mapLock.Unlock()
	for k, val := range v.rtRumtimes {
		val.Dispose()
		delete(v.rtRumtimes, k)
	}
}

func (v *JSEnv) EmptyObject() *goja.Object {
	return v.jsvm.EmptyObject()
}

func (env *JSEnv) BuildObject(rootPath string, inmap map[string]interface{}) *goja.Object {
	root := env.EmptyObject()
	for k, v := range inmap {
		err := root.Set(k, v)
		if err != nil {
			env.logger.LogPrintf(env.logPrefix, hiedalog.DLN_WARN, "export object '%s.%s' failed: VM.RegisterObject: %v", rootPath, v, err)
		}
	}
	return root
}

func (v *JSEnv) lsrt(call goja.FunctionCall) goja.Value {
	v.mapLock.RLock()
	defer v.mapLock.RUnlock()
	l := make([]string, 0, len(v.rtRumtimes))
	for k, _ := range v.rtRumtimes {
		l = append(l, k)
	}
	ret := v.jsvm.VMToValue(l)
	return ret
}

func (v *JSEnv) GetCurrentScopeName() string {
	return v.jsvm.GetCurrentScopeName()
}

func (v *JSEnv) prepareBasicJsEnv() {
	_ = v.jsvm.RegisterObject("module", v.jsvm.GetGlobalObject())
	_ = v.jsvm.RegisterObject("lsrt", v.lsrt)
}

func (v *JSEnv) ThrowException(i interface{}) {
	v.jsvm.ThrowException(i)
}

func (v *JSEnv) ToValue(i interface{}) goja.Value {
	return v.jsvm.ToValue(i)
}