How to use node-elm-compiler - 10 common examples

var intervalId = setInterval(function(){
    if (runningInstances >= maxInstances) return;
    runningInstances += 1;
    clearInterval(intervalId);

    // If we are running in watch mode, and we have previously compiled
    // the current file, then let the user know that elm-make is running
    // and can be slow
    if (alreadyCompiledFiles.indexOf(resourcePath) > -1){
      console.log('Started compiling Elm..');
    }

    var compilation = elmCompiler.compileToString(files, options)
      .then(function(v) { runningInstances -= 1; return { kind: 'success', result: v }; })
      .catch(function(v) { runningInstances -= 1; return { kind: 'error', error: v }; });

    promises.push(compilation);

    Promise.all(promises)
      .then(function(results) {
        var output = results[results.length - 1]; // compilation output is always last

        if (output.kind == 'success') {
          alreadyCompiledFiles.push(resourcePath);
          callback(null, output.result);
        } else {
          output.error.message = 'Compiler process exited with error ' + output.error.message;
          callback(output.error);
        }

cmd: cmd,
        args: args,
        options: spawnOptions
      }, function(err, result, exitCode) {
        // Log any stdout using grunt.log.ok and any stderr using grunt.log.error
        _.each({ok: result.stdout, error: result.stderr}, function(output, logType) {
          if (output && output.length > 0) {
            grunt.log[logType](output);
          }
        });

        callback(err);
      })
    };

    return elmCompile(sources, _.defaults({spawn: spawn}, options));
  }

build() {
    let options = Object.assign({}, this.options);
    let files = this.listFiles();
    if (!files.length) {
      // Nothing to build
      return;
    }

    return compileToString(files, options)
      .then(data => {
        // elm-make output
        let jsStr = data.toString();

        // fix module exports
        jsStr =
          `
          var elmScope = {};
          (function() {
            ${jsStr}
          }).call(elmScope)
          export default elmScope.Elm;
          `;

        // build
        const dir = path.join(this.outputPath, this.destDir);

var compile = function (filename) {
  return compiler.compileToString([filename], {yes: true, cwd: fixturesDir})
    .then(function (data) {
      return [data.toString(), 'module.exports = Elm;'].join('\n');
    });
}

var compile = function (filename) {
  return compiler.compileToString([filename], {cwd: fixturesDir})
    .then(function (data) {
      return data.toString();
    });
};

var temp = require('temp').track()
var compiler = require('node-elm-compiler')
var meow = require('meow')

var cli = meow(`
    Usage
      $ elm-json-schema 
`)

if (!fs.existsSync('./elm-package.json')) {
  fail('Error: This command needs to be executed from the root of the elm project.')
}

var sourcePath = cli.input[0]
var targetPath = temp.path({ suffix: '.js' })
compiler.compileSync([sourcePath], {
  yes: true,
  output: targetPath,
  processOpts: { stdio: 'pipe' }
})
var Elm = require(targetPath)
var app = Elm.Main.worker()
app.ports.emit.subscribe(function (json) {
  console.log(json)
})

function fail (msg) {
  process.stderr.write(msg)
  process.exit(1)
}

var rendererFileContents = templates.generateRendererFile(moduleNames);
fs.writeFileSync(privateMainPath, rendererFileContents);

var nativeString = templates.generateNativeModuleString(projectName);
fs.writeFileSync(nativePath, nativeString);

if (isVerbose) console.log('wrote template files to..', renderDirName);

var options = {
    yes: true,
    cwd: dirPath,
    output: 'elm.js'
};


var compileProcess = compile(privateMainPath, options);


compileProcess.on('exit',
    function(exitCode){
        if (exitCode !== 0){
            console.log("Exited with the code", exitCode);
            console.log('Trying to proceed anyway..');
        }

        var Elm = require(path.join(dirPath, 'elm.js'));
        var elmApp = Elm.PrivateMain.worker();
        elmApp.ports.htmlOut.subscribe(function(htmlOutput){

            htmlOutput.map(function(group){
                var outputFile = group[0];
                var html = group[1];

await new Promise((resolve) => {
        compile([mainModuleFilename], {
          yes: true,
          report,
          pathToMake: pathToElmMake,
          output: outputCompiledFilename,
          processOpts: {
            stdio: [0, elmCompileStdoutFd, elmCompileStderrFd]
          }
        }).on('close', resolve);
      });
    } catch (e) {

return new Promise((resolve, reject) => {
    const newFile = path.join(
      outDir,
      path.basename(file).replace('.elm', '.js')
    )

    elm
      .compile(path.join(cwd, file), {
        output: newFile,
        cwd: cwd,
        yes: true,
        processOpts: {
          stdio: 'inherit',
        },
      })
      .on('close', exitCode => {
        if (exitCode === 0) {
          resolve(newFile)
        } else {
          reject('node-elm-compiler Errored with exit code 1')
        }
      })
  })

return new Promise((resolve, reject) => {
    NodeElmCompiler.compileToString(...args)
    .then(data => resolve({ type: 'ok', data }))
    .catch(data => resolve({ type: 'error', data }))
  })
}