util/util.go

package util

import (
	"bytes"
	"crypto/md5"
	"crypto/sha1"
	"crypto/sha256"
	"crypto/sha512"
	_ "embed"
	"encoding/hex"
	"encoding/json"
	"path/filepath"
	"runtime"
	"strings"
	"text/template"
	"time"

	"apigo.cc/gojs"
	"apigo.cc/gojs/goja"
	"github.com/ssgo/u"
	"gopkg.in/yaml.v3"
)

//go:embed util.ts
var utilTS string

//go:embed README.md
var utilMD string

func init() {
	obj := map[string]any{
		"json": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			if r, err := json.Marshal(args.Arguments[0].Export()); err == nil {
				return vm.ToValue(string(r))
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"jsonP": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			if r, err := json.Marshal(args.Arguments[0].Export()); err == nil {
				r1 := bytes.Buffer{}
				if err2 := json.Indent(&r1, r, "", "  "); err2 == nil {
					return vm.ToValue(string(r))
				} else {
					return vm.ToValue(string(r))
				}
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"unJson": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			var r any
			if err := json.Unmarshal(u.Bytes(args.Arguments[0].Export()), &r); err == nil {
				return vm.ToValue(r)
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"yaml": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			if r, err := yaml.Marshal(args.Arguments[0].Export()); err == nil {
				return vm.ToValue(string(r))
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"unYaml": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			var r any
			if err := yaml.Unmarshal(u.Bytes(args.Arguments[0].Export()), &r); err == nil {
				return vm.ToValue(r)
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"save": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(2)
			filename := args.Str(0)
			var data []byte
			var err error
			if strings.HasSuffix(filename, ".yml") || strings.HasSuffix(filename, ".yaml") {
				data, err = yaml.Marshal(args.Any(1))
			} else {
				data, err = json.Marshal(args.Any(1))
			}
			if err == nil {
				if err = u.WriteFileBytes(gojs.FindPath(vm, filename), data); err != nil {
					panic(vm.NewGoError(err))
				}
				return nil
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"load": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			filename := args.Str(0)
			if data, err := u.ReadFileBytes(gojs.FindPath(vm, filename)); err == nil {
				var r any
				if strings.HasSuffix(filename, ".yml") || strings.HasSuffix(filename, ".yaml") {
					err = yaml.Unmarshal(data, &r)
				} else {
					err = json.Unmarshal(data, &r)
				}
				if err == nil {
					return vm.ToValue(r)
				} else {
					panic(vm.NewGoError(err))
				}
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"base64": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(u.Base64(u.Bytes(args.Arguments[0].Export())))
		},
		"unBase64": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(u.UnBase64(args.Str(0)))
		},
		"urlBase64": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(u.UrlBase64String(args.Str(0)))
		},
		"unUrlBase64": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(u.UnUrlBase64(args.Str(0)))
		},
		"hex": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(hex.EncodeToString(u.Bytes(args.Arguments[0].Export())))
		},
		"unHex": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			if r, err := hex.DecodeString(args.Str(0)); err == nil {
				return vm.ToValue(r)
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"aes": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(3)
			if r, err := u.EncryptAesBytes(u.Bytes(args.Arguments[0].Export()), u.Bytes(args.Arguments[1].Export()), u.Bytes(args.Arguments[2].Export())); err == nil {
				return vm.ToValue(r)
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"unAes": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(3)
			if r, err := u.DecryptAesBytes(u.Bytes(args.Arguments[0].Export()), u.Bytes(args.Arguments[1].Export()), u.Bytes(args.Arguments[2].Export())); err == nil {
				return vm.ToValue(r)
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"gzip": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			if r, err := u.Gzip(u.Bytes(args.Arguments[0].Export())); err == nil {
				return vm.ToValue(r)
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"gunzip": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			if r, err := u.Gunzip(u.Bytes(args.Arguments[0].Export())); err == nil {
				return vm.ToValue(r)
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"id": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			return vm.ToValue(u.Id12())
		},
		"uniqueId": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			return vm.ToValue(u.UniqueId())
		},
		"token": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			size := 20
			if len(argsIn.Arguments) > 0 {
				size = u.Int(argsIn.Arguments[0].Export())
			}
			return vm.ToValue(u.MakeToken(size))
		},
		"md5": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			hash := md5.New()
			for _, v := range args.Array(0) {
				hash.Write(u.Bytes(v))
			}
			return vm.ToValue(hash.Sum(nil))
		},
		"sha1": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			hash := sha1.New()
			for _, v := range args.Array(0) {
				hash.Write(u.Bytes(v))
			}
			return vm.ToValue(hash.Sum(nil))
		},
		"sha256": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			hash := sha256.New()
			for _, v := range args.Array(0) {
				hash.Write(u.Bytes(v))
			}
			return vm.ToValue(hash.Sum(nil))
		},
		"sha512": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			hash := sha512.New()
			for _, v := range args.Array(0) {
				hash.Write(u.Bytes(v))
			}
			return vm.ToValue(hash.Sum(nil))
		},
		"tpl": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(2)
			var functions = map[string]any{}
			if len(argsIn.Arguments) > 2 {
				obj := argsIn.Arguments[2].ToObject(vm)
				for _, k := range obj.Keys() {
					v := obj.Get(k)
					if cb, ok := goja.AssertFunction(v); ok {
						functions[k] = func(in string) string {
							if r, err := cb(argsIn.This, vm.ToValue(in)); err == nil {
								return r.String()
							}
							return ""
						}
					}
				}
			}

			buf := bytes.NewBuffer(make([]byte, 0))
			var err error
			tpl := template.New("tpl")
			if len(functions) > 0 {
				tpl.Funcs(functions)
			}
			if tpl, err = tpl.Parse(args.Str(0)); err == nil {
				err = tpl.Execute(buf, args.Arguments[1].Export())
			}
			if err != nil {
				panic(vm.NewGoError(err))
			}
			return vm.ToValue(buf.String())
		},
		"sleep": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			time.Sleep(time.Duration(args.Int64(0)) * time.Millisecond)
			return nil
		},
		"setTimeout": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			callback := args.Func(0)
			timeout := time.Duration(args.Int64(1)) * time.Millisecond
			if callback != nil {
				go func() {
					if timeout > 0 {
						time.Sleep(timeout)
					}
					if _, err := callback(args.This, args.Arguments[2:]...); err != nil {
						args.Logger.Error(err.Error())
					}
				}()
			}
			return nil
		},
		"shell": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			a := make([]string, len(args.Arguments)-1)
			for i := 1; i < len(args.Arguments); i++ {
				a[i-1] = args.Str(i)
			}

			if r, err := u.RunCommand(args.Str(0), a...); err == nil {
				return vm.ToValue(r)
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"toDatetime": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(time.UnixMilli(args.Int64(0)).Format("2006-01-02 15:04:05"))
		},
		"fromDatetime": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			timeStr := args.Str(0)
			if len(timeStr) > 19 {
				timeStr = timeStr[0:19]
			}
			if strings.ContainsRune(timeStr, 'T') {
				timeStr = strings.ReplaceAll(timeStr, "T", " ")
			}
			if tm, err := time.ParseInLocation("2006-01-02 15:04:05", timeStr, time.Local); err == nil {
				return vm.ToValue(tm.UnixMilli())
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"toDate": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(time.UnixMilli(args.Int64(0)).Format("2006-01-02"))
		},
		"fromDate": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			timeStr := args.Str(0)
			if len(timeStr) > 10 {
				timeStr = timeStr[0:10]
			}
			if tm, err := time.ParseInLocation("2006-01-02", timeStr, time.Local); err == nil {
				return vm.ToValue(tm.UnixMilli())
			} else {
				panic(vm.NewGoError(err))
			}
		},
		"os": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			return vm.ToValue(runtime.GOOS)
		},
		"arch": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			return vm.ToValue(runtime.GOARCH)
		},
		"joinPath": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(filepath.Join(args.StrArray(0)...))
		},
		"getPathDir": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(filepath.Dir(args.Str(0)))
		},
		"getPathBase": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(filepath.Base(args.Str(0)))
		},
		"getPathVolume": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(filepath.VolumeName(args.Str(0)))
		},
		"absPath": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			r, err := filepath.Abs(args.Str(0))
			if err != nil {
				panic(vm.NewGoError(err))
			}
			return vm.ToValue(r)
		},
		"cleanPath": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(filepath.Clean(args.Str(0)))
		},
		"isLocalPath": func(argsIn goja.FunctionCall, vm *goja.Runtime) goja.Value {
			args := gojs.MakeArgs(&argsIn, vm).Check(1)
			return vm.ToValue(filepath.IsLocal(args.Str(0)))
		},
	}

	gojs.Register("apigo.cc/gojs/util", gojs.Module{
		Object:  obj,
		TsCode:  utilTS,
		Example: utilMD,
	})
}