10 examples of 'how to run angularjs project in visual studio code' in JavaScript

333
function run(path, projecttype, buildtype, buildarchs, buildtarget) {
334
    build(path, buildtype, buildarchs);
335
    switch (buildtarget){
336
        case "device":
337
            device(path, projecttype, buildtype, buildarchs);
338
            break;
339
        case "emulator":
340
            emulator(path, projecttype, buildtype, buildarchs);
341
            break;
342
        case null:
343
            Log("WARNING: [ --target= | --emulator | --device ] not specified, defaulting to --emulator");
344
            emulator(path, projecttype, buildtype, buildarchs);
345
            break;
346
        default:
347
            // if buildTarget is neither "device", "emulator" or null
348
            // then it is a name of target
349
            target(path, projecttype, buildtype, buildarchs, buildtarget);
350
            break;
351
    }
352
}

75
async function run(tsParamPath) {
76
  const tsPath = path.resolve(tsParamPath);
77
  const testWriter = new NgTestWriter(tsPath);
78
  const testGenerator: any = testWriter.getTestGenerator(); // get test generator. e.g. ComponentData
79
  const ejsData = await testGenerator.getEjsData(); // parse typescript
80
81
  const source = testGenerator.typescript;
82
  // console.log('>>>>>>>>>>>>> source', source);
83
84
  const result = ts.transpileModule(source, {
85
    compilerOptions : {
86
      module: ts.ModuleKind.CommonJS, experimentalDecorators: true, target: ts.ScriptTarget.ES2015
87
      //module: ts.ModuleKind.ES2015, experimentalDecorators: true, target: ts.ScriptTarget.ES5
88
    }
89
  });
90
  console.log('>>>>>>>>>>>>> result', result.outputText);
91
92
  const res = fs.writeFileSync('tmp.js', '' + result.outputText);
93
94
  // function requireFromString(src) {
95
  //   var filename = path.resolve('tmp.js');
96
  //   var Module: any = module.constructor;
97
  //   var m = new Module(filename, __dirname);
98
  //   m._compile(src, filename);
99
  //   return m.exports;
100
  // }
101
102
  // console.log('>>>>>>>>>>>>>>>>......', requireFromString(result.outputText));
103
  const module = await import(path.resolve('tmp.js'));
104
  const Klass = module[ejsData.className];
105
  console.log('module....... 1', Klass);
106
  console.log('module....... 2', ''+Klass.constructor);
107
  console.log('module....... 3', new Klass());
108
  // console.log('module....... ', klass);
109
110
  // const tmpPath = 
111
  // const x = eval(result.outputText);
112
  // console.log(';>>>>>>>>>>>>>>>>>>>> x >>>.', x);
113
  // const program = ts.createProgram([tsPath], {module: ts.ModuleKind.CommonJS, experimentalDecorators: true});
114
  // console.log('>>>>>>>>> program >>>>', program.emit());
115
  //   })
116
117
  // compile typescript
118
  // tsc --target es2015 --module commonjs --experimentalDecorators true --outDir foo src2/for-component/example/example.component.ts 
119
}

18
(async function main() {
19
  if (!argv.standalone) {
20
    await nailgunServer.start(argv.host, argv.port);
21
  }
22
  const pluginDir = path.dirname(__dirname);
23
  childProcess.spawnSync(
24
    "prettier",
25
    [
26
      `--plugin=${pluginDir}`,
27
      "--server-auto-start=false",
28
      "--write",
29
      `${argv.path}/**/*.{trigger,cls}`,
30
    ],
31
    {
32
      cwd: process.cwd(),
33
      env: process.env,
34
      stdio: [process.stdin, process.stdout, process.stderr],
35
      encoding: "utf-8",
36
      shell: true,
37
    },
38
  );
39
  if (!argv.standalone) {
40
    await nailgunServer.stop(argv.host, argv.port);
41
  }
42
})();

51
async function runNgsscbuild(options: Options) {
52
  // A "run" can have multiple outputs, and contains progress information.
53
  const run = await architect.scheduleBuilder(
54
    'angular-server-side-configuration:ngsscbuild', options, { logger });
55
56
  // The "result" member (of type BuilderOutput) is the next output.
57
  const output = await run.result;
58
59
  // Stop the builder from running. This stops Architect from keeping
60
  // the builder-associated states in memory, since builders keep waiting
61
  // to be scheduled.
62
  await run.stop();
63
  return output;
64
}

48
static build(visualPackage, options) {
49
    options = options || {};
50
    let lessFilename = visualPackage.config.style;
51
    return new Promise((resolve, reject) => {
52
        let lessPath = visualPackage.buildPath(lessFilename);
53
        let dropCssPath = visualPackage.buildPath(config.build.dropFolder, config.build.css);
54
        let lessContent = fs.readFileSync(lessPath).toString();
55
        let lessMinifiedOptions = {
56
            sourceMap: {
57
                sourceMapURL: path.basename(dropCssPath) + '.map'
58
            },
59
            compress: true
60
        };
61
62
        less.render(lessContent, options.minify ? lessMinifiedOptions : null).then(cssContent => {
63
            fs.ensureDirSync(path.dirname(dropCssPath));
64
            fs.writeFileSync(dropCssPath, cssContent.css);
65
            createProdCss(dropCssPath, cssContent.css);
66
            fs.writeFileSync(dropCssPath + '.map', cssContent.map);
67
            resolve();
68
        }).catch(e => {
69
            let messages = [
70
                {
71
                    filename: lessFilename,
72
                    line: e.line,
73
                    column: e.column,
74
                    message: e.message,
75
                    type: 'less'
76
                }
77
            ];
78
            reject(messages);
79
        });
80
    });
81
}

31
runTests(testFilesPattern: string, code: CodeUtil): void {
32
    let self = this;
33
    let browser: VSBrowser = new VSBrowser(this.codeVersion, this.customSettings);
34
    const universalPattern = testFilesPattern.replace(/'/g, '');
35
    const testFiles = glob.sync(universalPattern);
36
37
    testFiles.forEach((file) => {
38
        if (fs.existsSync(file) && file.substr(-3) === '.js') {
39
            this.mocha.addFile(file);
40
        }
41
    });
42
43
    this.mocha.suite.afterEach(async function () {
44
        if (this.currentTest && this.currentTest.state !== 'passed') {
45
            try {
46
                await browser.takeScreenshot(this.currentTest.fullTitle());
47
            } catch (err) {
48
                console.log('Screenshot capture failed');
49
            }
50
        }
51
    });
52
53
    this.mocha.suite.beforeAll(async function () {
54
        this.timeout(15000);
55
        await browser.start(self.chromeBin);
56
        await browser.waitForWorkbench();
57
        await new Promise((res) => { setTimeout(res, 2000); });
58
    });
59
60
    this.mocha.suite.afterAll(async function() {
61
        this.timeout(15000);
62
        await browser.quit();
63
64
        code.uninstallExtension(self.cleanup);
65
    });
66
67
    this.mocha.run((failures) => {
68
        process.exitCode = failures ? 1 : 0;
69
    });
70
}

53
function compileAngularSource(src, path) {
54
  src = importAngularSources(readFileSync(debundle(path)).toString());
55
  const {code} = babel(src, {presets: ['es2015']});
56
  return code;
57
}

24
testBuild () {
25
  this.output = path.resolve('./test/lib')
26
27
  this.clean()
28
29
  this.tasks.add(`Generate test files in ${this.output}`, next => {
30
    let excluded = []
31
    let ui = new this.Table()
32
33
    ui.div({
34
      text: this.COLORS.subtle('Generated Files:'),
35
      padding: [1, 0, 0, 5]
36
    })
37
38
    console.log(ui.toString())
39
40
    this.walk(this.source).forEach(filepath => {
41
      let content = this.readFileSync(filepath)
42
43
      // If the file is a partial, exclude it
44
      if (this.exclusion.test(content)) {
45
        this.PARTIALS[filepath] = content
46
        excluded.push(this.relativePath(filepath))
47
      } else {
48
        this.writeFileSync(this.outputDirectory(filepath), this.includePartials(filepath, content))
49
        this.success(`     ${this.relativePath(filepath)}`)
50
      }
51
    })
52
53
    ui = new this.Table()
54
55
    ui.div({
56
      text: this.COLORS.subtle('Partials Identified:') + '\n' + this.COLORS.info(excluded.join('\n')),
57
      padding: [1, 0, 1, 5]
58
    })
59
60
    console.log(ui.toString())
61
62
    next()
63
  })
64
}

9
function run(projectDataFile, assetsFolder) {
10
    const projectData = JSON.parse(fs.readFileSync(projectDataFile).toString());
11
12
    rimraf.sync(`${assetsFolder}/**/*`);
13
14
    try {
15
        fs.mkdirSync(assetsFolder);
16
    } catch (err) {
17
        // Dont fail if dir already exists
18
    }
19
20
    const siteAssetsDirSrc = './docs/site-settings/assets';
21
    const siteAssetDirDest = `${assetsFolder}/site-settings`;
22
    mkdirp.sync(siteAssetDirDest);
23
    const siteAssetFiles = fs.readdirSync(siteAssetsDirSrc);
24
    for (let i = 0; i < siteAssetFiles.length; i++) {
25
        console.log(chalk.cyan(`\tCopying Site Asset: '${siteAssetsDirSrc}/${siteAssetFiles[i]}'`));
26
        fs.copyFileSync(`${siteAssetsDirSrc}/${siteAssetFiles[i]}`, `${siteAssetDirDest}/${siteAssetFiles[i]}`);
27
    }
28
29
    for (let i = 0; i < projectData.length; i++) {
30
        const project = projectData[i];
31
32
        for (let j = 0; j < project.versions.length; j++) {
33
            const version = project.versions[j];
34
35
            for (let k = 0; k < version.pages.length; k++) {
36
37
                if (version.pages[k].assets) {
38
                    for(let l = 0; l < version.pages[k].assets.length; l++) {
39
                        const assetSrc = path.resolve(path.join('.', version.pages[k].assets[l]));
40
                        const assetDest =  path.resolve(path.join(assetsFolder, version.pages[k].assets[l].replace('/docs', '')));
41
                        console.log(chalk.cyan(`\tCopying: '${assetSrc}'`));
42
                        console.log(chalk.cyan(`\tTo: '${assetDest}'\n`));
43
                        mkdirp.sync(path.dirname(assetDest));
44
                        fs.copyFileSync(assetSrc, assetDest);
45
                    }
46
                }
47
            }
48
        }
49
    }
50
}

19
export default function runJest(project, options = []) {
20
  // eslint-disable-next-line no-undef
21
  jest.setTimeout(15000);
22
23
  return execa(
24
    'jest',
25
    [
26
      '--useStderr',
27
      '--no-watchman',
28
      '--no-cache',
29
      '--projects',
30
      path.join(rootDir, '__tests__', '__fixtures__', project),
31
    ].concat(options),
32
    {
33
      env: process.env,
34
      reject: false,
35
    },
36
    // eslint-disable-next-line promise/prefer-await-to-then
37
  ).then(
38
    ({ stdout, stderr }) =>
39
      `${stripColor(normalize(stderr))}\n${stripColor(normalize(stdout))}`,
40
  );
41
}