@makano/rew 1.0.1

package/lib/coffeescript/scope.js

@@ -0,0 +1,187 @@
+// Generated by CoffeeScript 2.7.0
+(function() {
+  // The **Scope** class regulates lexical scoping within CoffeeScript. As you
+  // generate code, you create a tree of scopes in the same shape as the nested
+  // function bodies. Each scope knows about the variables declared within it,
+  // and has a reference to its parent enclosing scope. In this way, we know which
+  // variables are new and need to be declared with `var`, and which are shared
+  // with external scopes.
+  var Scope,
+    indexOf = [].indexOf;
+
+  exports.Scope = Scope = class Scope {
+    // Initialize a scope with its parent, for lookups up the chain,
+    // as well as a reference to the **Block** node it belongs to, which is
+    // where it should declare its variables, a reference to the function that
+    // it belongs to, and a list of variables referenced in the source code
+    // and therefore should be avoided when generating variables. Also track comments
+    // that should be output as part of variable declarations.
+    constructor(parent, expressions, method, referencedVars) {
+      var ref, ref1;
+      this.parent = parent;
+      this.expressions = expressions;
+      this.method = method;
+      this.referencedVars = referencedVars;
+      this.variables = [
+        {
+          name: 'arguments',
+          type: 'arguments'
+        }
+      ];
+      this.comments = {};
+      this.positions = {};
+      if (!this.parent) {
+        this.utilities = {};
+      }
+      // The `@root` is the top-level **Scope** object for a given file.
+      this.root = (ref = (ref1 = this.parent) != null ? ref1.root : void 0) != null ? ref : this;
+    }
+
+    // Adds a new variable or overrides an existing one.
+    add(name, type, immediate) {
+      if (this.shared && !immediate) {
+        return this.parent.add(name, type, immediate);
+      }
+      if (Object.prototype.hasOwnProperty.call(this.positions, name)) {
+        return this.variables[this.positions[name]].type = type;
+      } else {
+        return this.positions[name] = this.variables.push({name, type}) - 1;
+      }
+    }
+
+    // When `super` is called, we need to find the name of the current method we're
+    // in, so that we know how to invoke the same method of the parent class. This
+    // can get complicated if super is being called from an inner function.
+    // `namedMethod` will walk up the scope tree until it either finds the first
+    // function object that has a name filled in, or bottoms out.
+    namedMethod() {
+      var ref;
+      if (((ref = this.method) != null ? ref.name : void 0) || !this.parent) {
+        return this.method;
+      }
+      return this.parent.namedMethod();
+    }
+
+    // Look up a variable name in lexical scope, and declare it if it does not
+    // already exist.
+    find(name, type = 'var') {
+      if (this.check(name)) {
+        return true;
+      }
+      this.add(name, type);
+      return false;
+    }
+
+    // Reserve a variable name as originating from a function parameter for this
+    // scope. No `var` required for internal references.
+    parameter(name) {
+      if (this.shared && this.parent.check(name, true)) {
+        return;
+      }
+      return this.add(name, 'param');
+    }
+
+    // Just check to see if a variable has already been declared, without reserving,
+    // walks up to the root scope.
+    check(name) {
+      var ref;
+      return !!(this.type(name) || ((ref = this.parent) != null ? ref.check(name) : void 0));
+    }
+
+    // Generate a temporary variable name at the given index.
+    temporary(name, index, single = false) {
+      var diff, endCode, letter, newCode, num, startCode;
+      if (single) {
+        startCode = name.charCodeAt(0);
+        endCode = 'z'.charCodeAt(0);
+        diff = endCode - startCode;
+        newCode = startCode + index % (diff + 1);
+        letter = String.fromCharCode(newCode);
+        num = Math.floor(index / (diff + 1));
+        return `${letter}${num || ''}`;
+      } else {
+        return `${name}${index || ''}`;
+      }
+    }
+
+    // Gets the type of a variable.
+    type(name) {
+      var i, len, ref, v;
+      ref = this.variables;
+      for (i = 0, len = ref.length; i < len; i++) {
+        v = ref[i];
+        if (v.name === name) {
+          return v.type;
+        }
+      }
+      return null;
+    }
+
+    // If we need to store an intermediate result, find an available name for a
+    // compiler-generated variable. `_var`, `_var2`, and so on...
+    freeVariable(name, options = {}) {
+      var index, ref, temp;
+      index = 0;
+      while (true) {
+        temp = this.temporary(name, index, options.single);
+        if (!(this.check(temp) || indexOf.call(this.root.referencedVars, temp) >= 0)) {
+          break;
+        }
+        index++;
+      }
+      if ((ref = options.reserve) != null ? ref : true) {
+        this.add(temp, 'var', true);
+      }
+      return temp;
+    }
+
+    // Ensure that an assignment is made at the top of this scope
+    // (or at the top-level scope, if requested).
+    assign(name, value) {
+      this.add(name, {
+        value,
+        assigned: true
+      }, true);
+      return this.hasAssignments = true;
+    }
+
+    // Does this scope have any declared variables?
+    hasDeclarations() {
+      return !!this.declaredVariables().length;
+    }
+
+    // Return the list of variables first declared in this scope.
+    declaredVariables() {
+      var v;
+      return ((function() {
+        var i, len, ref, results;
+        ref = this.variables;
+        results = [];
+        for (i = 0, len = ref.length; i < len; i++) {
+          v = ref[i];
+          if (v.type === 'var') {
+            results.push(v.name);
+          }
+        }
+        return results;
+      }).call(this)).sort();
+    }
+
+    // Return the list of assignments that are supposed to be made at the top
+    // of this scope.
+    assignedVariables() {
+      var i, len, ref, results, v;
+      ref = this.variables;
+      results = [];
+      for (i = 0, len = ref.length; i < len; i++) {
+        v = ref[i];
+        if (v.type.assigned) {
+          results.push(`${v.name} = ${v.type.value}`);
+        }
+      }
+      return results;
+    }
+
+  };
+
+}).call(this);

package/lib/coffeescript/sourcemap.js

@@ -0,0 +1,229 @@
+// Generated by CoffeeScript 2.7.0
+(function() {
+  // Source maps allow JavaScript runtimes to match running JavaScript back to
+  // the original source code that corresponds to it. This can be minified
+  // JavaScript, but in our case, we're concerned with mapping pretty-printed
+  // JavaScript back to CoffeeScript.
+
+  // In order to produce maps, we must keep track of positions (line number, column number)
+  // that originated every node in the syntax tree, and be able to generate a
+  // [map file](https://docs.google.com/document/d/1U1RGAehQwRypUTovF1KRlpiOFze0b-_2gc6fAH0KY0k/edit)
+  // — which is a compact, VLQ-encoded representation of the JSON serialization
+  // of this information — to write out alongside the generated JavaScript.
+
+  // LineMap
+  // -------
+
+  // A **LineMap** object keeps track of information about original line and column
+  // positions for a single line of output JavaScript code.
+  // **SourceMaps** are implemented in terms of **LineMaps**.
+  var LineMap, SourceMap;
+
+  LineMap = class LineMap {
+    constructor(line1) {
+      this.line = line1;
+      this.columns = [];
+    }
+
+    add(column, [sourceLine, sourceColumn], options = {}) {
+      if (this.columns[column] && options.noReplace) {
+        return;
+      }
+      return this.columns[column] = {
+        line: this.line,
+        column,
+        sourceLine,
+        sourceColumn
+      };
+    }
+
+    sourceLocation(column) {
+      var mapping;
+      while (!((mapping = this.columns[column]) || (column <= 0))) {
+        column--;
+      }
+      return mapping && [mapping.sourceLine, mapping.sourceColumn];
+    }
+
+  };
+
+  SourceMap = (function() {
+    var BASE64_CHARS, VLQ_CONTINUATION_BIT, VLQ_SHIFT, VLQ_VALUE_MASK;
+
+    // SourceMap
+    // ---------
+
+      // Maps locations in a single generated JavaScript file back to locations in
+    // the original CoffeeScript source file.
+
+      // This is intentionally agnostic towards how a source map might be represented on
+    // disk. Once the compiler is ready to produce a "v3"-style source map, we can walk
+    // through the arrays of line and column buffer to produce it.
+    class SourceMap {
+      constructor() {
+        this.lines = [];
+      }
+
+      // Adds a mapping to this SourceMap. `sourceLocation` and `generatedLocation`
+      // are both `[line, column]` arrays. If `options.noReplace` is true, then if there
+      // is already a mapping for the specified `line` and `column`, this will have no
+      // effect.
+      add(sourceLocation, generatedLocation, options = {}) {
+        var base, column, line, lineMap;
+        [line, column] = generatedLocation;
+        lineMap = ((base = this.lines)[line] || (base[line] = new LineMap(line)));
+        return lineMap.add(column, sourceLocation, options);
+      }
+
+      // Look up the original position of a given `line` and `column` in the generated
+      // code.
+      sourceLocation([line, column]) {
+        var lineMap;
+        while (!((lineMap = this.lines[line]) || (line <= 0))) {
+          line--;
+        }
+        return lineMap && lineMap.sourceLocation(column);
+      }
+
+      static registerCompiled(filename, source, sourcemap) {
+        if (sourcemap != null) {
+          return SourceMap.sourceMaps[filename] = sourcemap;
+        }
+      }
+
+      static getSourceMap(filename) {
+        return SourceMap.sourceMaps[filename];
+      }
+
+      // V3 SourceMap Generation
+      // -----------------------
+
+        // Builds up a V3 source map, returning the generated JSON as a string.
+      // `options.sourceRoot` may be used to specify the sourceRoot written to the source
+      // map.  Also, `options.sourceFiles` and `options.generatedFile` may be passed to
+      // set "sources" and "file", respectively.
+      generate(options = {}, code = null) {
+        var buffer, i, j, lastColumn, lastSourceColumn, lastSourceLine, len, len1, lineMap, lineNumber, mapping, needComma, ref, ref1, sources, v3, writingline;
+        writingline = 0;
+        lastColumn = 0;
+        lastSourceLine = 0;
+        lastSourceColumn = 0;
+        needComma = false;
+        buffer = "";
+        ref = this.lines;
+        for (lineNumber = i = 0, len = ref.length; i < len; lineNumber = ++i) {
+          lineMap = ref[lineNumber];
+          if (lineMap) {
+            ref1 = lineMap.columns;
+            for (j = 0, len1 = ref1.length; j < len1; j++) {
+              mapping = ref1[j];
+              if (!(mapping)) {
+                continue;
+              }
+              while (writingline < mapping.line) {
+                lastColumn = 0;
+                needComma = false;
+                buffer += ";";
+                writingline++;
+              }
+              // Write a comma if we've already written a segment on this line.
+              if (needComma) {
+                buffer += ",";
+                needComma = false;
+              }
+              // Write the next segment. Segments can be 1, 4, or 5 values.  If just one, then it
+              // is a generated column which doesn't match anything in the source code.
+
+              // The starting column in the generated source, relative to any previous recorded
+              // column for the current line:
+              buffer += this.encodeVlq(mapping.column - lastColumn);
+              lastColumn = mapping.column;
+              // The index into the list of sources:
+              buffer += this.encodeVlq(0);
+              // The starting line in the original source, relative to the previous source line.
+              buffer += this.encodeVlq(mapping.sourceLine - lastSourceLine);
+              lastSourceLine = mapping.sourceLine;
+              // The starting column in the original source, relative to the previous column.
+              buffer += this.encodeVlq(mapping.sourceColumn - lastSourceColumn);
+              lastSourceColumn = mapping.sourceColumn;
+              needComma = true;
+            }
+          }
+        }
+        // Produce the canonical JSON object format for a "v3" source map.
+        sources = options.sourceFiles ? options.sourceFiles : options.filename ? [options.filename] : ['<anonymous>'];
+        v3 = {
+          version: 3,
+          file: options.generatedFile || '',
+          sourceRoot: options.sourceRoot || '',
+          sources: sources,
+          names: [],
+          mappings: buffer
+        };
+        if (options.sourceMap || options.inlineMap) {
+          v3.sourcesContent = [code];
+        }
+        return v3;
+      }
+
+      encodeVlq(value) {
+        var answer, nextChunk, signBit, valueToEncode;
+        answer = '';
+        // Least significant bit represents the sign.
+        signBit = value < 0 ? 1 : 0;
+        // The next bits are the actual value.
+        valueToEncode = (Math.abs(value) << 1) + signBit;
+        // Make sure we encode at least one character, even if valueToEncode is 0.
+        while (valueToEncode || !answer) {
+          nextChunk = valueToEncode & VLQ_VALUE_MASK;
+          valueToEncode = valueToEncode >> VLQ_SHIFT;
+          if (valueToEncode) {
+            nextChunk |= VLQ_CONTINUATION_BIT;
+          }
+          answer += this.encodeBase64(nextChunk);
+        }
+        return answer;
+      }
+
+      encodeBase64(value) {
+        return BASE64_CHARS[value] || (function() {
+          throw new Error(`Cannot Base64 encode value: ${value}`);
+        })();
+      }
+
+    };
+
+    // Caching
+    // -------
+
+    // A static source maps cache `filename`: `map`. These are used for transforming
+    // stack traces and are currently set in `CoffeeScript.compile` for all files
+    // compiled with the source maps option.
+    SourceMap.sourceMaps = Object.create(null);
+
+    // Base64 VLQ Encoding
+    // -------------------
+
+    // Note that SourceMap VLQ encoding is "backwards".  MIDI-style VLQ encoding puts
+    // the most-significant-bit (MSB) from the original value into the MSB of the VLQ
+    // encoded value (see [Wikipedia](https://en.wikipedia.org/wiki/File:Uintvar_coding.svg)).
+    // SourceMap VLQ does things the other way around, with the least significat four
+    // bits of the original value encoded into the first byte of the VLQ encoded value.
+    VLQ_SHIFT = 5;
+
+    VLQ_CONTINUATION_BIT = 1 << VLQ_SHIFT; // 0010 0000
+
+    VLQ_VALUE_MASK = VLQ_CONTINUATION_BIT - 1; // 0001 1111
+
+    // Regular Base64 Encoding
+    // -----------------------
+    BASE64_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
+
+    return SourceMap;
+
+  }).call(this);
+
+  // Our API for source maps is just the `SourceMap` class.
+  module.exports = SourceMap;
+
+}).call(this);

package/lib/rew/cli/cli.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+
+const yargs = require('yargs/yargs');
+const path = require('path');
+const { hideBin } = require('yargs/helpers');
+const { fork } = require('child_process');
+const { watch } = require('chokidar');
+const utils = require('./utils');
+
+yargs(hideBin(process.argv))
+  .command(
+    '$0 <file>', 
+    'Run the specified file', 
+    (yargs) => {
+      yargs
+        .positional('file', {
+          describe: 'File to run',
+          type: 'string',
+        })
+        .option('watch', {
+          alias: 'w',
+          describe: 'Watch the file for changes',
+          type: 'boolean',
+        });
+    },
+    (argv) => {
+      const filePath = path.resolve(process.cwd(), argv.file);
+      const watching = [];
+      const watchIt = (file) => {
+        if(watching.includes(file)) return;
+        watch(file).on('change', () => runIt());
+        watching.push(file);
+      }
+      let prevFork;
+      const runIt = () => {
+        if(argv.watch) console.clear();
+        if(prevFork && !prevFork.killed) prevFork.kill?.();
+        prevFork = fork(path.resolve(__dirname, './run.js'))
+        .on('message', (data) => {
+          if(argv.watch){
+            data.forEach(file => {
+              watchIt(file);
+            });
+          } else {
+            process.exit();
+          }
+        }).send({ filePath, watch: argv.watch });
+        if(argv.watch) watchIt(filePath);
+      }
+      runIt();
+    }
+  )
+  .command(
+    'conf <command> [path] [key] [value]', 
+    'Configuration management', 
+    (yargs) => {
+      yargs
+        .positional('command', {
+          describe: 'Configuration command (get, set, remove)',
+          type: 'string',
+          choices: ['get', 'set', 'remove'],
+        })
+        .positional('path', {
+          describe: 'Configuration path',
+          type: 'string',
+          default: '',
+        })
+        .positional('key', {
+          describe: 'Key to get/set/remove',
+          type: 'string',
+          default: '',
+        })
+        .positional('value', {
+          describe: 'Value to set (only used with "set" command)',
+          type: 'string',
+          default: '',
+        });
+    },
+    (argv) => {
+      const { command, path, key, value } = argv;
+      const result = utils.conf(command, path, key, value);
+      if(result) console.log(result);
+    }
+  )
+  .command('create <path>',  'Create a new project', (yargs) => {
+    yargs
+      .positional('path', {
+        describe: 'Path of the project to create',
+        type: 'string',
+      });
+    },
+    (argv) => {
+      utils.createProject(argv.path);
+    }
+  )
+  .command('run <path | package>',  'Run an app', (yargs) => {
+    yargs
+      .positional('path', {
+        describe: 'Path of the app to run',
+        type: 'string',
+      });
+    },
+    (argv) => {
+      utils.runApp(argv.path);
+    }
+  )
+  .command('build <file>', 'Build the specified file', (yargs) => {
+    yargs
+      .positional('file', {
+        describe: 'File to build',
+        type: 'string',
+      });
+  }, (argv) => {
+    console.log(`Building file: ${argv.file}`);
+  })
+  .help()
+  .argv;

package/lib/rew/cli/log.js

@@ -0,0 +1,40 @@
+
+let start = true;
+const startPrefix =  '╭';
+const middlePrefix = '├';
+const separator =    '│';
+const endPrefix =    '╰';
+
+const log = module.exports.log = function(...toPrint){
+  let prefix = start ? startPrefix : middlePrefix;
+  let returns = false;
+  if(toPrint[toPrint.length-1] == ':end') {
+    prefix = endPrefix;
+    toPrint.pop();
+  }
+  if(toPrint[toPrint.length-1] == ':returns') {
+    returns = true;
+    toPrint.pop();
+  }
+  if(prefix == endPrefix && start) prefix = separator;
+  if(!start) console.log(separator);
+  if(start) start = false;
+  if(returns) return [prefix, ...toPrint].join(' ');
+  else console.log(prefix, ...toPrint);
+}
+
+module.exports.logget = function(...toPrint){
+  let args = [...toPrint];
+  if(toPrint[toPrint.length-1] == ':end') {
+    let l = args.pop();
+    args.push(':returns', l);
+  } else {
+    args.push(':returns');
+  }
+  return log(...args);
+}
+
+log.startPrefix = startPrefix;
+log.middlePrefix = middlePrefix;
+log.separator = separator;
+log.endPrefix = endPrefix;

package/lib/rew/cli/run.js

@@ -0,0 +1,20 @@
+const path = require('path');
+const { run } = require('../main');
+const { watch } = require('fs');
+
+
+function exec(filePath){
+  return run(filePath)
+    .context.module.imports;
+}
+
+
+process.on('message', ({ filePath, watch }) => {
+  const imports = exec(filePath);
+  if(watch){
+    process.send(imports);
+    process.exit();
+  } else {
+    process.exit();
+  }
+});