1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
'use strict';
// Flags: --experimental-vm-modules
const common = require('../common');
const assert = require('assert');
const { URL } = require('url');
const { SourceTextModule } = require('vm');
async function simple() {
const foo = new SourceTextModule('export default 5;');
await foo.link(common.mustNotCall());
const bar = new SourceTextModule('import five from "foo"; five');
assert.deepStrictEqual(bar.dependencySpecifiers, ['foo']);
await bar.link(common.mustCall((specifier, module) => {
assert.strictEqual(module, bar);
assert.strictEqual(specifier, 'foo');
return foo;
}));
bar.instantiate();
assert.strictEqual((await bar.evaluate()).result, 5);
}
async function depth() {
const foo = new SourceTextModule('export default 5');
await foo.link(common.mustNotCall());
async function getProxy(parentName, parentModule) {
const mod = new SourceTextModule(`
import ${parentName} from '${parentName}';
export default ${parentName};
`);
await mod.link(common.mustCall((specifier, module) => {
assert.strictEqual(module, mod);
assert.strictEqual(specifier, parentName);
return parentModule;
}));
return mod;
}
const bar = await getProxy('foo', foo);
const baz = await getProxy('bar', bar);
const barz = await getProxy('baz', baz);
barz.instantiate();
await barz.evaluate();
assert.strictEqual(barz.namespace.default, 5);
}
async function circular() {
const foo = new SourceTextModule(`
import getFoo from 'bar';
export let foo = 42;
export default getFoo();
`);
const bar = new SourceTextModule(`
import { foo } from 'foo';
export default function getFoo() {
return foo;
}
`);
await foo.link(common.mustCall(async (fooSpecifier, fooModule) => {
assert.strictEqual(fooModule, foo);
assert.strictEqual(fooSpecifier, 'bar');
await bar.link(common.mustCall((barSpecifier, barModule) => {
assert.strictEqual(barModule, bar);
assert.strictEqual(barSpecifier, 'foo');
assert.strictEqual(foo.linkingStatus, 'linking');
return foo;
}));
assert.strictEqual(bar.linkingStatus, 'linked');
return bar;
}));
foo.instantiate();
await foo.evaluate();
assert.strictEqual(foo.namespace.default, 42);
}
async function circular2() {
const sourceMap = {
'root': `
import * as a from './a.mjs';
import * as b from './b.mjs';
if (!('fromA' in a))
throw new Error();
if (!('fromB' in a))
throw new Error();
if (!('fromA' in b))
throw new Error();
if (!('fromB' in b))
throw new Error();
`,
'./a.mjs': `
export * from './b.mjs';
export var fromA;
`,
'./b.mjs': `
export * from './a.mjs';
export var fromB;
`
};
const moduleMap = new Map();
const rootModule = new SourceTextModule(sourceMap.root, { url: 'vm:root' });
async function link(specifier, referencingModule) {
if (moduleMap.has(specifier)) {
return moduleMap.get(specifier);
}
const mod = new SourceTextModule(sourceMap[specifier], {
url: new URL(specifier, 'file:///').href,
});
moduleMap.set(specifier, mod);
return mod;
}
await rootModule.link(link);
rootModule.instantiate();
await rootModule.evaluate();
}
const finished = common.mustCall();
(async function main() {
await simple();
await depth();
await circular();
await circular2();
finished();
})();
|
