typenative 0.4.0 → 0.4.1
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.github/workflows/ci.yml +2 -0
- package/CHANGELOG.md +201 -0
- package/CONTRIBUTION.md +1 -1
- package/bin/cli.js +1 -0
- package/bin/go/bridge.js +74 -14
- package/bin/go/convert.js +48 -0
- package/bin/go/metadata.js +13 -4
- package/bin/go/overrides.js +4 -6
- package/bin/go/stdlib.generated.js +2 -0
- package/bin/index.js +117 -0
- package/bin/main.js +1 -0
- package/bin/node/child_process.js +51 -3
- package/bin/node/cluster.js +41 -3
- package/bin/node/core.js +1 -1
- package/bin/node/crypto.js +205 -4
- package/bin/node/dgram.js +230 -6
- package/bin/node/dns.js +470 -7
- package/bin/node/errno_tables.js +445 -0
- package/bin/node/fs.js +21 -14
- package/bin/node/http.js +128 -30
- package/bin/node/http2.js +4 -1
- package/bin/node/module_v8.js +142 -0
- package/bin/node/net.js +9 -6
- package/bin/node/process.js +242 -0
- package/bin/node/readline.js +271 -0
- package/bin/node/registry.js +2 -1
- package/bin/node/sqlite.js +60 -12
- package/bin/node/stream.js +139 -7
- package/bin/node/test.js +311 -19
- package/bin/node/url.js +23 -5
- package/bin/node/util.js +18 -1
- package/bin/node/util_extra.js +6 -30
- package/bin/node/worker_threads.js +79 -19
- package/bin/transpiler.js +4019 -497
- package/bin/typecheck-node.js +1 -0
- package/bin/version.js +1 -1
- package/conformance.md +1025 -884
- package/examples/README.md +5 -5
- package/examples/json-server/README.md +31 -29
- package/examples/json-server/bench.mjs +130 -38
- package/package.json +1 -1
- package/types/typenative-go.d.ts +23 -0
- package/types/typenative-npm.d.ts +169 -5
- package/types/typenative.d.ts +185 -11
package/bin/node/url.js
CHANGED
|
@@ -18,7 +18,23 @@ type TnURL struct {
|
|
|
18
18
|
|
|
19
19
|
var tnSpecialSchemes = map[string]string{"http:": "80", "https:": "443", "ws:": "80", "wss:": "443", "ftp:": "21", "file:": ""}
|
|
20
20
|
|
|
21
|
-
|
|
21
|
+
// The leading "scheme:" of s (/^[A-Za-z][A-Za-z0-9+.-]*:/), "" when there is none
|
|
22
|
+
func tnURLScheme(s string) string {
|
|
23
|
+
for i := 0; i < len(s); i++ {
|
|
24
|
+
c := s[i]
|
|
25
|
+
switch {
|
|
26
|
+
case c >= 'a' && c <= 'z' || c >= 'A' && c <= 'Z':
|
|
27
|
+
case i > 0 && (c >= '0' && c <= '9' || c == '+' || c == '.' || c == '-'):
|
|
28
|
+
case i > 0 && c == ':':
|
|
29
|
+
return s[:i+1]
|
|
30
|
+
default:
|
|
31
|
+
return ""
|
|
32
|
+
}
|
|
33
|
+
}
|
|
34
|
+
return ""
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
var tnURLStrip = strings.NewReplacer("\\t", "", "\\n", "", "\\r", "")
|
|
22
38
|
|
|
23
39
|
func tnInvalidURL(input string) *TnError {
|
|
24
40
|
e := TnNodeError("TypeError", "ERR_INVALID_URL", "Invalid URL")
|
|
@@ -213,7 +229,9 @@ func tnCopyURL(b *TnURL) *TnURL {
|
|
|
213
229
|
|
|
214
230
|
func tnParseURLString(input string, base *TnURL) (*TnURL, bool) {
|
|
215
231
|
input = strings.TrimFunc(input, func(r rune) bool { return r <= 0x20 })
|
|
216
|
-
|
|
232
|
+
if strings.ContainsAny(input, "\\t\\n\\r") {
|
|
233
|
+
input = tnURLStrip.Replace(input)
|
|
234
|
+
}
|
|
217
235
|
fragment, hasFragment := "", false
|
|
218
236
|
if i := strings.Index(input, "#"); i >= 0 {
|
|
219
237
|
fragment, hasFragment = input[i+1:], true
|
|
@@ -225,7 +243,7 @@ func tnParseURLString(input string, base *TnURL) (*TnURL, bool) {
|
|
|
225
243
|
input = input[:i]
|
|
226
244
|
}
|
|
227
245
|
u := &TnURL{}
|
|
228
|
-
if scheme :=
|
|
246
|
+
if scheme := tnURLScheme(input); scheme != "" {
|
|
229
247
|
u.protocol = strings.ToLower(scheme)
|
|
230
248
|
rest := input[len(scheme):]
|
|
231
249
|
if u.special() {
|
|
@@ -451,7 +469,7 @@ func (u *TnURL) Set_href(v string) {
|
|
|
451
469
|
|
|
452
470
|
func (u *TnURL) Set_protocol(v string) {
|
|
453
471
|
v = strings.ToLower(strings.TrimSuffix(v, ":")) + ":"
|
|
454
|
-
if
|
|
472
|
+
if tnURLScheme(v) == "" {
|
|
455
473
|
return
|
|
456
474
|
}
|
|
457
475
|
_, toSpecial := tnSpecialSchemes[v]
|
|
@@ -809,7 +827,7 @@ func TnDomainToUnicode(domain string) string {
|
|
|
809
827
|
}`;
|
|
810
828
|
export function registerUrl(r) {
|
|
811
829
|
defineModule(r, 'url');
|
|
812
|
-
defineHelper(r, 'nodeUrl', ['encoding/hex', 'fmt', 'net/url', 'path/filepath', 'reflect', '
|
|
830
|
+
defineHelper(r, 'nodeUrl', ['encoding/hex', 'fmt', 'net/url', 'path/filepath', 'reflect', 'runtime', 'sort', 'strconv', 'strings', 'unicode/utf16', 'unsafe'], ['error', 'dynamic', 'punycode', 'pathToFileURL', 'nodeInvoke'], urlHelper);
|
|
813
831
|
defineClass(r, 'url.URL', '*TnURL', 'class', 'toString=string; toJSON=string', '', 'href=string; protocol=string; username=string; password=string; host=string; hostname=string; port=string; pathname=string; search=string; hash=string; origin=string; searchParams=*TnURLSearchParams', 'href; protocol; username; password; host; hostname; port; pathname; search; hash');
|
|
814
832
|
defineClass(r, 'url.URLSearchParams', '*TnURLSearchParams', 'class', 'append=; set=; delete=; get=*string; getAll=[]string; has=bool; sort=; toString=string; keys=[]string; values=[]string; entries=[][]string; forEach=', '', 'size=float64', '');
|
|
815
833
|
r.iterators['*TnURLSearchParams'] = 'entries';
|
package/bin/node/util.js
CHANGED
|
@@ -196,6 +196,9 @@ func (ins *tnInspector) format(v interface{}, depth int) string {
|
|
|
196
196
|
name, values := x.TnTypedInspect()
|
|
197
197
|
return name + " " + ins.format(values, depth)
|
|
198
198
|
case time.Time:
|
|
199
|
+
if x.IsZero() {
|
|
200
|
+
return "Invalid Date"
|
|
201
|
+
}
|
|
199
202
|
return x.UTC().Format("2006-01-02T15:04:05.000Z07:00")
|
|
200
203
|
case *regexp.Regexp:
|
|
201
204
|
if x == nil {
|
|
@@ -327,8 +330,16 @@ func (ins *tnInspector) formatCompound(v interface{}, rv reflect.Value, depth in
|
|
|
327
330
|
isTop := depth == 0
|
|
328
331
|
if withEntries, ok := v.(interface{ Entries() [][]interface{} }); ok {
|
|
329
332
|
entries = withEntries.Entries()
|
|
330
|
-
|
|
333
|
+
// new Map() / new Set() are tagged; untagged maps are records unless a
|
|
334
|
+
// key is not a string
|
|
335
|
+
jsKind := uint8(0)
|
|
336
|
+
if tagged, ok := v.(interface{ TnJSKind() uint8 }); ok {
|
|
337
|
+
jsKind = tagged.TnJSKind()
|
|
338
|
+
}
|
|
339
|
+
if jsKind == 2 || (jsKind == 0 && tnInspectSetLike(rv)) {
|
|
331
340
|
kind = "set"
|
|
341
|
+
} else if jsKind == 1 {
|
|
342
|
+
kind = "map"
|
|
332
343
|
} else {
|
|
333
344
|
kind = "map"
|
|
334
345
|
stringKeys := true
|
|
@@ -762,6 +773,12 @@ func TnUtilFormat(args ...interface{}) string {
|
|
|
762
773
|
} else {
|
|
763
774
|
args[i] = *p
|
|
764
775
|
}
|
|
776
|
+
case string:
|
|
777
|
+
default:
|
|
778
|
+
// String enum members (type E string) print as strings
|
|
779
|
+
if rv := reflect.ValueOf(a); rv.Kind() == reflect.String {
|
|
780
|
+
args[i] = rv.String()
|
|
781
|
+
}
|
|
765
782
|
}
|
|
766
783
|
}
|
|
767
784
|
first, isString := args[0].(string)
|
package/bin/node/util_extra.js
CHANGED
|
@@ -253,31 +253,13 @@ func tnArgEntries(v interface{}) [][2]interface{} {
|
|
|
253
253
|
|
|
254
254
|
// --- system errors ---
|
|
255
255
|
|
|
256
|
-
var tnSystemErrors = map[string]syscall.Errno{
|
|
257
|
-
"E2BIG": syscall.E2BIG, "EACCES": syscall.EACCES, "EADDRINUSE": syscall.EADDRINUSE, "EADDRNOTAVAIL": syscall.EADDRNOTAVAIL,
|
|
258
|
-
"EAFNOSUPPORT": syscall.EAFNOSUPPORT, "EAGAIN": syscall.EAGAIN, "EALREADY": syscall.EALREADY, "EBADF": syscall.EBADF,
|
|
259
|
-
"EBUSY": syscall.EBUSY, "ECANCELED": syscall.ECANCELED, "ECONNABORTED": syscall.ECONNABORTED, "ECONNREFUSED": syscall.ECONNREFUSED,
|
|
260
|
-
"ECONNRESET": syscall.ECONNRESET, "EDESTADDRREQ": syscall.EDESTADDRREQ, "EEXIST": syscall.EEXIST, "EFAULT": syscall.EFAULT,
|
|
261
|
-
"EFBIG": syscall.EFBIG, "EHOSTUNREACH": syscall.EHOSTUNREACH, "EINTR": syscall.EINTR, "EINVAL": syscall.EINVAL,
|
|
262
|
-
"EIO": syscall.EIO, "EISCONN": syscall.EISCONN, "EISDIR": syscall.EISDIR, "ELOOP": syscall.ELOOP, "EMFILE": syscall.EMFILE,
|
|
263
|
-
"EMLINK": syscall.EMLINK, "EMSGSIZE": syscall.EMSGSIZE, "ENAMETOOLONG": syscall.ENAMETOOLONG, "ENETDOWN": syscall.ENETDOWN,
|
|
264
|
-
"ENETUNREACH": syscall.ENETUNREACH, "ENFILE": syscall.ENFILE, "ENOBUFS": syscall.ENOBUFS, "ENODEV": syscall.ENODEV,
|
|
265
|
-
"ENOENT": syscall.ENOENT, "ENOMEM": syscall.ENOMEM, "ENOSPC": syscall.ENOSPC, "ENOSYS": syscall.ENOSYS,
|
|
266
|
-
"ENOTCONN": syscall.ENOTCONN, "ENOTDIR": syscall.ENOTDIR, "ENOTEMPTY": syscall.ENOTEMPTY, "ENOTSOCK": syscall.ENOTSOCK,
|
|
267
|
-
"ENOTSUP": syscall.ENOTSUP, "ENXIO": syscall.ENXIO, "EPERM": syscall.EPERM, "EPIPE": syscall.EPIPE,
|
|
268
|
-
"EPROTO": syscall.EPROTO, "EPROTONOSUPPORT": syscall.EPROTONOSUPPORT, "EPROTOTYPE": syscall.EPROTOTYPE,
|
|
269
|
-
"ERANGE": syscall.ERANGE, "EROFS": syscall.EROFS, "ESPIPE": syscall.ESPIPE, "ESRCH": syscall.ESRCH,
|
|
270
|
-
"ETIMEDOUT": syscall.ETIMEDOUT, "ETXTBSY": syscall.ETXTBSY, "EXDEV": syscall.EXDEV,
|
|
271
|
-
}
|
|
272
|
-
|
|
273
256
|
func tnSystemErrorEntry(errno float64) (string, string, bool) {
|
|
274
257
|
if errno >= 0 || errno != float64(int64(errno)) {
|
|
275
258
|
panic(TnNodeError("RangeError", "ERR_OUT_OF_RANGE", "The value of \\"err\\" is out of range. It must be a negative integer. Received "+TnNumStr(errno)))
|
|
276
259
|
}
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
|
|
280
|
-
return name, e.Error(), true
|
|
260
|
+
for _, e := range tnUvErrorList {
|
|
261
|
+
if tnUvErrnos[e[0]] == errno {
|
|
262
|
+
return e[0], e[1], true
|
|
281
263
|
}
|
|
282
264
|
}
|
|
283
265
|
return "", "", false
|
|
@@ -301,14 +283,8 @@ func TnGetSystemErrorMessage(errno float64) string {
|
|
|
301
283
|
|
|
302
284
|
func TnGetSystemErrorMap() *TnMap[float64, []string] {
|
|
303
285
|
m := TnNewMap[float64, []string]()
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
names = append(names, name)
|
|
307
|
-
}
|
|
308
|
-
sort.Slice(names, func(i, j int) bool { return tnSystemErrors[names[i]] < tnSystemErrors[names[j]] })
|
|
309
|
-
for _, name := range names {
|
|
310
|
-
e := tnSystemErrors[name]
|
|
311
|
-
m.Set(-float64(e), []string{name, e.Error()})
|
|
286
|
+
for _, e := range tnUvErrorList {
|
|
287
|
+
m.Set(tnUvErrnos[e[0]], []string{e[0], e[1]})
|
|
312
288
|
}
|
|
313
289
|
return m
|
|
314
290
|
}
|
|
@@ -560,7 +536,7 @@ func TnDebuglogEnabled(section string) bool { return tnDebugEnabled(section) }
|
|
|
560
536
|
// toUSVString: invalid sequences become U+FFFD
|
|
561
537
|
func TnToUSVString(s string) string { return strings.ToValidUTF8(s, "\uFFFD") }`;
|
|
562
538
|
export function registerUtilExtra(r) {
|
|
563
|
-
defineHelper(r, 'nodeUtilExtra', ['fmt', 'os', 'reflect', 'regexp', 'sort', 'strconv', 'strings', '
|
|
539
|
+
defineHelper(r, 'nodeUtilExtra', ['fmt', 'os', 'reflect', 'regexp', 'sort', 'strconv', 'strings', 'unsafe'], ['nodeUtil', 'dynamic', 'orderedMap', 'error', 'eventLoop', 'nodeEvents', 'fsErrors', 'uvErrno'], utilExtraHelper);
|
|
564
540
|
const use = () => r.helper('nodeUtilExtra');
|
|
565
541
|
const fn = (key, result, emit) => {
|
|
566
542
|
r.functions[key] = (c) => {
|
|
@@ -6,8 +6,17 @@
|
|
|
6
6
|
// workerData are set. MessageChannel / MessagePort / BroadcastChannel work
|
|
7
7
|
// within one process. The worker's stdout / stderr are the parent's; an
|
|
8
8
|
// uncaught exception in a worker becomes an 'error' event and exit code 1.
|
|
9
|
-
import { defineClass, defineHelper, defineModule, setResults
|
|
9
|
+
import { defineClass, defineHelper, defineModule, setResults } from './registry.js';
|
|
10
10
|
const cloneHelper = `// Structured clone (subset): values to and from JSON with type tags
|
|
11
|
+
// Objects keep their key order: {"$tn": "Object", "k": keys, "v": values}
|
|
12
|
+
func tnCloneObject(keys []string, values []interface{}) map[string]interface{} {
|
|
13
|
+
k := make([]interface{}, len(keys))
|
|
14
|
+
for i, key := range keys {
|
|
15
|
+
k[i] = key
|
|
16
|
+
}
|
|
17
|
+
return map[string]interface{}{"$tn": "Object", "k": k, "v": values}
|
|
18
|
+
}
|
|
19
|
+
|
|
11
20
|
func tnCloneEncode(v interface{}) interface{} {
|
|
12
21
|
switch x := v.(type) {
|
|
13
22
|
case nil:
|
|
@@ -44,11 +53,16 @@ func tnCloneEncode(v interface{}) interface{} {
|
|
|
44
53
|
}
|
|
45
54
|
return map[string]interface{}{"$tn": "Error", "message": x.message, "code": x.code, "props": props}
|
|
46
55
|
case map[string]interface{}:
|
|
47
|
-
|
|
48
|
-
for k
|
|
49
|
-
|
|
56
|
+
keys := make([]string, 0, len(x))
|
|
57
|
+
for k := range x {
|
|
58
|
+
keys = append(keys, k)
|
|
50
59
|
}
|
|
51
|
-
|
|
60
|
+
sort.Strings(keys)
|
|
61
|
+
values := make([]interface{}, len(keys))
|
|
62
|
+
for i, k := range keys {
|
|
63
|
+
values[i] = tnCloneEncode(x[k])
|
|
64
|
+
}
|
|
65
|
+
return tnCloneObject(keys, values)
|
|
52
66
|
case []interface{}:
|
|
53
67
|
out := make([]interface{}, len(x))
|
|
54
68
|
for i, val := range x {
|
|
@@ -57,7 +71,30 @@ func tnCloneEncode(v interface{}) interface{} {
|
|
|
57
71
|
return out
|
|
58
72
|
}
|
|
59
73
|
if withEntries, ok := v.(interface{ Entries() [][]interface{} }); ok {
|
|
60
|
-
|
|
74
|
+
kind := uint8(0)
|
|
75
|
+
if tagged, ok := v.(interface{ TnJSKind() uint8 }); ok {
|
|
76
|
+
kind = tagged.TnJSKind()
|
|
77
|
+
}
|
|
78
|
+
// a record (string keys, not made by new Map()) is a plain object
|
|
79
|
+
if kind == 0 {
|
|
80
|
+
entries := withEntries.Entries()
|
|
81
|
+
keys := make([]string, 0, len(entries))
|
|
82
|
+
values := make([]interface{}, 0, len(entries))
|
|
83
|
+
plain := true
|
|
84
|
+
for _, e := range entries {
|
|
85
|
+
k, isString := e[0].(string)
|
|
86
|
+
if !isString {
|
|
87
|
+
plain = false
|
|
88
|
+
break
|
|
89
|
+
}
|
|
90
|
+
keys = append(keys, k)
|
|
91
|
+
values = append(values, tnCloneEncode(e[1]))
|
|
92
|
+
}
|
|
93
|
+
if plain {
|
|
94
|
+
return tnCloneObject(keys, values)
|
|
95
|
+
}
|
|
96
|
+
}
|
|
97
|
+
if kind == 2 {
|
|
61
98
|
values := []interface{}{}
|
|
62
99
|
for _, e := range withEntries.Entries() {
|
|
63
100
|
values = append(values, tnCloneEncode(e[0]))
|
|
@@ -92,16 +129,18 @@ func tnCloneEncode(v interface{}) interface{} {
|
|
|
92
129
|
}
|
|
93
130
|
if rv.Elem().Kind() == reflect.Struct {
|
|
94
131
|
sv := rv.Elem()
|
|
95
|
-
|
|
132
|
+
keys := []string{}
|
|
133
|
+
values := []interface{}{}
|
|
96
134
|
for i := 0; i < sv.NumField(); i++ {
|
|
97
135
|
f := sv.Field(i)
|
|
98
136
|
if f.Kind() == reflect.Func {
|
|
99
137
|
continue
|
|
100
138
|
}
|
|
101
139
|
value := reflect.NewAt(f.Type(), unsafe.Pointer(f.UnsafeAddr())).Elem().Interface()
|
|
102
|
-
|
|
140
|
+
keys = append(keys, strings.TrimSuffix(sv.Type().Field(i).Name, "_"))
|
|
141
|
+
values = append(values, tnCloneEncode(value))
|
|
103
142
|
}
|
|
104
|
-
return
|
|
143
|
+
return tnCloneObject(keys, values)
|
|
105
144
|
}
|
|
106
145
|
return tnCloneEncode(rv.Elem().Interface())
|
|
107
146
|
case reflect.Float32, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
|
|
@@ -141,7 +180,7 @@ func tnCloneDecode(v interface{}) interface{} {
|
|
|
141
180
|
}
|
|
142
181
|
return e
|
|
143
182
|
case "Map":
|
|
144
|
-
m := TnNewMap[interface{}, interface{}]()
|
|
183
|
+
m := TnJSCollection(TnNewMap[interface{}, interface{}](), 1)
|
|
145
184
|
if pairs, ok := x["v"].([]interface{}); ok {
|
|
146
185
|
for _, p := range pairs {
|
|
147
186
|
if pair, ok := p.([]interface{}); ok && len(pair) == 2 {
|
|
@@ -150,8 +189,19 @@ func tnCloneDecode(v interface{}) interface{} {
|
|
|
150
189
|
}
|
|
151
190
|
}
|
|
152
191
|
return m
|
|
192
|
+
case "Object":
|
|
193
|
+
// an ordered record, as plain objects print and stringify in order
|
|
194
|
+
m := TnNewMap[string, interface{}]()
|
|
195
|
+
keys, _ := x["k"].([]interface{})
|
|
196
|
+
values, _ := x["v"].([]interface{})
|
|
197
|
+
for i, k := range keys {
|
|
198
|
+
if i < len(values) {
|
|
199
|
+
m.Set(TnJSString(k), tnCloneDecode(values[i]))
|
|
200
|
+
}
|
|
201
|
+
}
|
|
202
|
+
return m
|
|
153
203
|
case "Set":
|
|
154
|
-
m := TnNewMap[interface{}, interface{}]()
|
|
204
|
+
m := TnJSCollection(TnNewMap[interface{}, interface{}](), 2)
|
|
155
205
|
if values, ok := x["v"].([]interface{}); ok {
|
|
156
206
|
for _, val := range values {
|
|
157
207
|
d := tnCloneDecode(val)
|
|
@@ -410,8 +460,10 @@ func init() {
|
|
|
410
460
|
var setup map[string]interface{}
|
|
411
461
|
json.Unmarshal(payload, &setup)
|
|
412
462
|
TnWorkerData = tnCloneDecode(setup["workerData"])
|
|
413
|
-
if env, ok := tnCloneDecode(setup["environmentData"]).(
|
|
414
|
-
|
|
463
|
+
if env, ok := tnCloneDecode(setup["environmentData"]).(*TnMap[string, interface{}]); ok {
|
|
464
|
+
for _, k := range env.Keys() {
|
|
465
|
+
tnEnvironmentData[k] = env.Get(k)
|
|
466
|
+
}
|
|
415
467
|
}
|
|
416
468
|
TnThreadID, _ = setup["threadId"].(float64)
|
|
417
469
|
port := tnNewPort()
|
|
@@ -463,6 +515,13 @@ type TnWorker struct {
|
|
|
463
515
|
|
|
464
516
|
func (w *TnWorker) Get_threadId() float64 { return w.threadId }
|
|
465
517
|
|
|
518
|
+
// new Worker('./w.ts'): runs the entry point compiled from that file
|
|
519
|
+
func TnNewWorkerAt(entry string, filename interface{}, options ...interface{}) *TnWorker {
|
|
520
|
+
tnNextEntry = entry
|
|
521
|
+
defer func() { tnNextEntry = "" }()
|
|
522
|
+
return TnNewWorker(filename, options...)
|
|
523
|
+
}
|
|
524
|
+
|
|
466
525
|
func TnNewWorker(filename interface{}, options ...interface{}) *TnWorker {
|
|
467
526
|
tnNextThreadID++
|
|
468
527
|
w := &TnWorker{threadId: tnNextThreadID}
|
|
@@ -505,6 +564,7 @@ func TnNewWorker(filename interface{}, options ...interface{}) *TnWorker {
|
|
|
505
564
|
}
|
|
506
565
|
}
|
|
507
566
|
}
|
|
567
|
+
env = tnSpawnEntryEnv(env)
|
|
508
568
|
env = append(env, "TN_WORKER_ADDR="+ln.Addr().String(), "TN_WORKER_TOKEN="+token)
|
|
509
569
|
setup, err := json.Marshal(map[string]interface{}{
|
|
510
570
|
"workerData": tnCloneEncode(workerData),
|
|
@@ -658,8 +718,8 @@ func (w *TnWorker) unref() *TnWorker {
|
|
|
658
718
|
const EMITTER = 'on=*TnEventEmitter; once=*TnEventEmitter; addListener=*TnEventEmitter; off=*TnEventEmitter; removeListener=*TnEventEmitter; removeAllListeners=*TnEventEmitter; emit=bool; listenerCount=float64';
|
|
659
719
|
export function registerWorkerThreads(r) {
|
|
660
720
|
defineModule(r, 'worker_threads');
|
|
661
|
-
defineHelper(r, 'nodeClone', ['encoding/base64', 'encoding/json', 'fmt', 'math/big', 'reflect', 'strings', 'time', 'unsafe'], ['dynamic', 'orderedMap', 'error'], cloneHelper);
|
|
662
|
-
defineHelper(r, 'nodeWorker', ['bufio', 'crypto/rand', 'encoding/hex', 'encoding/json', 'fmt', 'net', 'os', 'os/exec', 'reflect', 'strings', 'sync', 'time'], ['nodeClone', 'nodeIpc', 'nodeEvents', 'eventLoop', 'nodeInvoke', 'dynamic', 'nodeChild'], workerHelper);
|
|
721
|
+
defineHelper(r, 'nodeClone', ['encoding/base64', 'encoding/json', 'fmt', 'math/big', 'reflect', 'sort', 'strings', 'time', 'unsafe'], ['dynamic', 'orderedMap', 'error'], cloneHelper);
|
|
722
|
+
defineHelper(r, 'nodeWorker', ['bufio', 'crypto/rand', 'encoding/hex', 'encoding/json', 'fmt', 'net', 'os', 'os/exec', 'reflect', 'strings', 'sync', 'time'], ['nodeClone', 'nodeIpc', 'nodeEvents', 'eventLoop', 'nodeInvoke', 'dynamic', 'nodeChild', 'entryPoints'], workerHelper);
|
|
663
723
|
const use = () => r.helper('nodeWorker');
|
|
664
724
|
defineClass(r, 'worker_threads.Worker', '*TnWorker', 'class', `${EMITTER}; postMessage=; terminate=chan float64; ref=*TnWorker; unref=*TnWorker`, '', 'threadId=float64', '');
|
|
665
725
|
defineClass(r, 'worker_threads.MessagePort', '*TnMessagePort', 'class', `${EMITTER}; postMessage=; start=; close=; ref=*TnMessagePort; unref=*TnMessagePort; hasRef=bool`, '', 'onmessage=interface{}', 'onmessage');
|
|
@@ -686,10 +746,10 @@ export function registerWorkerThreads(r) {
|
|
|
686
746
|
r.paramTypers['worker_threads.BroadcastChannel#addEventListener'] = (_n) => ['*TnMessageEvent'];
|
|
687
747
|
r.constructors['worker_threads.Worker'] = (c) => {
|
|
688
748
|
use();
|
|
689
|
-
//
|
|
690
|
-
|
|
691
|
-
|
|
692
|
-
|
|
749
|
+
// new Worker('./w.ts'): that file is compiled in as a second entry point
|
|
750
|
+
const entry = r.entryPoint(c.nodes[0]);
|
|
751
|
+
if (entry !== '')
|
|
752
|
+
return `TnNewWorkerAt(${JSON.stringify(entry)}, ${c.args.join(', ')})`;
|
|
693
753
|
return `TnNewWorker(${c.args.join(', ')})`;
|
|
694
754
|
};
|
|
695
755
|
r.constructors['worker_threads.MessageChannel'] = (_c) => {
|