refactor: move startup scripts to shims, add plugins

src/steps/bundle.ts

@@ -1,11 +1,11 @@
 import { NexeCompiler } from '../compiler'
-import { FuseBox, JSONPlugin, CSSPlugin, HTMLPlugin, QuantumPlugin } from 'fuse-box'
 import { readFileAsync, writeFileAsync } from '../util'
 import { resolve, relative } from 'path'
 import NativeModulePlugin from '../bundling/fuse-native-module-plugin'
 import { NexeOptions } from '../options'
 
 function createBundle(options: NexeOptions) {
+  const { FuseBox, JSONPlugin, CSSPlugin, HTMLPlugin, QuantumPlugin } = require('fuse-box')
   const plugins: any = [JSONPlugin(), CSSPlugin(), HTMLPlugin(), NativeModulePlugin(options.native)]
   if (options.compress) {
     plugins.push(
@@ -28,9 +28,9 @@ function createBundle(options: NexeOptions) {
   })
   const input = relative(options.cwd, options.input).replace(/\\/g, '/')
   fuse.bundle(options.name).instructions(`> ${input}`)
-  return fuse.run().then(x => {
+  return fuse.run().then((x: any) => {
     let output = ''
-    x.bundles.forEach(y => (output = y.context.output.lastPrimaryOutput.content!.toString()))
+    x.bundles.forEach((y: any) => (output = y.context.output.lastPrimaryOutput.content.toString()))
     return output
   })
 }

src/steps/cli.ts

@@ -33,14 +33,16 @@ function readStreamAsync(stream: NodeJS.ReadableStream): PromiseLike<string> {
  */
 export default async function cli(compiler: NexeCompiler, next: () => Promise<void>) {
   const { log } = compiler
-
+  let stdInUsed = false
   if (!process.stdin.isTTY) {
-    log.step('Using stdin as input')
+    stdInUsed = true
     compiler.input = await readStreamAsync(process.stdin)
   }
 
   await next()
 
+  log.step(`Bundling: '${stdInUsed ? '[stdin]' : compiler.options.input}'`)
+
   const target = compiler.options.targets.shift() as NexeTarget
   const deliverable = await compiler.compileAsync(target)
 

src/steps/shim-fs.ts

@@ -0,0 +1,93 @@
+import { Stats } from 'fs'
+import { ok } from 'assert'
+import { resolve, normalize } from 'path'
+
+const binary = (process as any).__nexe as NexeBinary
+ok(binary)
+const manifest = binary.resources
+const isString = (x: any): x is string => typeof x === 'string' || x instanceof String
+
+if (Object.keys(manifest).length) {
+  const fs = require('fs')
+  const originalReadFile = fs.readFile
+  const originalReadFileSync = fs.readFileSync
+  const resourceStart = binary.layout.resourceStart
+
+  let setupManifest = () => {
+    const manifest = binary.resources
+    Object.keys(manifest).forEach(key => {
+      const absolutePath = resolve(key)
+      if (!manifest[absolutePath]) {
+        manifest[absolutePath] = manifest[key]
+      }
+      const normalizedPath = normalize(key)
+      if (!manifest[normalizedPath]) {
+        manifest[normalizedPath] = manifest[key]
+      }
+    })
+    setupManifest = () => {}
+  }
+  //TODO track inflight fs reqs??
+  var nfs = {
+    readFile: function readFile(file: any, options: any, callback: any) {
+      setupManifest()
+      const entry = manifest[file]
+      if (!entry || !isString(file)) {
+        return originalReadFile.apply(fs, arguments)
+      }
+      const [offset, length] = entry
+      const resourceOffset = resourceStart + offset
+      const encoding = isString(options) ? options : null
+      callback = typeof options === 'function' ? options : callback
+
+      fs.open(process.execPath, 'r', function(err: Error, fd: number) {
+        if (err) return callback(err, null)
+        fs.read(fd, Buffer.alloc(length), 0, length, resourceOffset, function(
+          error: Error,
+          bytesRead: number,
+          result: Buffer
+        ) {
+          if (error) {
+            return fs.close(fd, function() {
+              callback(error, null)
+            })
+          }
+          fs.close(fd, function(err: Error) {
+            if (err) {
+              return callback(err, result)
+            }
+            callback(err, encoding ? result.toString(encoding) : result)
+          })
+        })
+      })
+    },
+    readFileSync: function readFileSync(file: any, options: any) {
+      setupManifest()
+      const entry = manifest[file]
+      if (!entry || !isString(file)) {
+        return originalReadFileSync.apply(fs, arguments)
+      }
+      const [offset, length] = entry
+      const resourceOffset = resourceStart + offset
+      const encoding = isString(options) ? options : null
+      const fd = fs.openSync(process.execPath, 'r')
+      const result = Buffer.alloc(length)
+      fs.readSync(fd, result, 0, length, resourceOffset)
+      fs.closeSync(fd)
+      return encoding ? result.toString(encoding) : result
+    }
+  }
+  Object.assign(fs, nfs)
+}
+
+interface NexeBinary {
+  resources: { [key: string]: number[] }
+  version: string
+  layout: {
+    stat: Stats
+    contentSize: number
+    contentStart: number
+    resourceSize: number
+    resourceStart: number
+  }
+}

src/steps/shim.ts

@@ -1,18 +1,25 @@
 import { NexeCompiler } from '../compiler'
 
+function wrap(code: string) {
+  return '!(function () {' + code + '})();'
+}
+
 export default function(compiler: NexeCompiler, next: () => Promise<void>) {
-  if (!compiler.options.fakeArgv) {
-    return next()
+  compiler.shims.push(wrap(compiler.getHeader()))
+
+  if (compiler.options.resources.length) {
+    compiler.shims.push(wrap('{{replace:lib/steps/shim-fs.js}}'))
   }
 
-  const nty = !process.stdin.isTTY
-  const input = nty ? '[stdin]' : compiler.options.input
-
-  compiler.input =
-    `!(() => {
-    var r = require('path').resolve;
-    process.argv.splice(1,0, ${nty ? `'${input}'` : `r("${input}")`});
-  })();` + compiler.input
+  if (compiler.options.fakeArgv) {
+    const nty = !process.stdin.isTTY
+    const input = nty ? '[stdin]' : compiler.options.input
+    compiler.shims.push(
+      wrap(`
+      var r = require('path').resolve; 
+      process.argv.splice(1,0, ${nty ? `'${input}'` : `r("${input}")`});`)
+    )
+  }
 
   return next()
 }