Initial commit

Author: tomitrescak

.gitignore

@@ -0,0 +1,2 @@
+node_modules
+dist

.vscode/settings.json

@@ -0,0 +1,4 @@
+// Place your settings in this file to overwrite default and user settings.
+{
+  "eslint.enable": false
+}

.vscode/tasks.json

@@ -0,0 +1,11 @@
+{
+  // See https://go.microsoft.com/fwlink/?LinkId=733558
+  // for the documentation about the tasks.json format
+  "version": "0.1.0",
+  "command": "tsc",
+  "isShellCommand": true,
+  "args": ["-w", "-p", "./src"],
+  "showOutput": "silent",
+  "isWatching": true,
+  "problemMatcher": "$tsc-watch"
+}

README.md

@@ -0,0 +1,20 @@
+# Introduction
+
+Tired of waiting for ES6 `imports` implementation in Node.JS?
+Tired of using transpilers with difficult defug and sourcemapping?
+
+This plugin transforms your ES6 imports to commonjs counterparts.
+No sourcemapping is needed.
+
+# How to use
+
+Simply import the registration script as a first line in your server:
+
+```js
+require('import-to-commonjs/dist/register');
+```
+
+# Known issues
+
+Currently none, but I'm pretty sure I missed some import cases. PRs welcome.
+

package.json

@@ -0,0 +1,20 @@
+{
+  "name": "import-to-commonjs",
+  "version": "0.0.2",
+  "description": "Transforms import statements to commonjs",
+  "main": "dist/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [
+    "NodeJs",
+    "ES6",
+    "CommonJS",
+    "Javascript"
+  ],
+  "author": "Tomi Trescak",
+  "license": "MIT",
+  "devDependencies": {
+    "assert": "^1.4.1"
+  }
+}

src/index.ts

@@ -0,0 +1,95 @@
+const importReg = /^import\s*((\* as )?\s*([\w_]+)\s*)?,?\s*(\{\s*([\w_,\s]*)\s\})?\s*(from\s+)?(['"][\._\-\w\/]+['"])/gm;
+const exportRef = /^export\s*(default)?\s*(const|let|var|class|function|interface)?\s*([\w_]*)/mg;
+
+export default function transform(source: string) {
+  importReg.lastIndex = 0;
+
+  // handle exports
+  const moduleExports: string[] = [];
+  let defaultExport: string = null;
+
+  exportRef.lastIndex = 0;
+  let match: RegExpExecArray = null;
+  while ((match = exportRef.exec(source)) != null) {
+    if (match[1]) {
+      if (defaultExport) {
+        console.error('Multiple default exports!');
+        throw new Error('Multiple default exports');
+      } else {
+        defaultExport = match[3];
+      }
+    } else {
+      moduleExports.push(match[3]);
+    }
+  }
+
+  // remove export statements
+  source = source.replace(/^export\s+(default)?\s*(function\s*\(|\{|\()?\s*/gm, (full: string, defaultKw: string, type: string) => {
+    // console.log(type);
+    if (type) {
+      if (type.match(/function\s/)) {
+        defaultExport = 'defaultFunction';
+        return 'function defaultFunction(';
+      } else if (type.match(/\{/)) {
+        defaultExport = 'defaultObject';
+        return 'const defaultObject = {';
+      } else if (type.match(/\(/)) {
+        defaultExport = 'defaultFunction';
+        return 'const defaultFunction = (';
+      }
+    }
+    return '';
+  });
+
+  // construct exports
+  let allExports = '';
+  if (moduleExports.length) {
+    // append export statement at the end of the file
+    moduleExports.forEach((e) => { allExports += `\nexports.${e} = ${e};` });
+  }
+  if (defaultExport) {
+    allExports += `\nexports.default = ${defaultExport};`;
+  }
+
+  source += allExports;
+
+  // handle imports
+  return source.replace(importReg,
+    (wholeMatch: string,
+      defaultImport: string,
+      defaultAs: string,
+      defaultAsVar: string,
+      specificImportWrapper: string,
+      specificImports: string,
+      fromKeyword: string,
+      source: string) => {
+
+      if (!fromKeyword) {
+        return `require(${source})`;
+      }
+      else if (defaultImport && specificImports) {
+        return handleDefaultImports(defaultAs, defaultAsVar, defaultImport, source) + 
+               '\n' +
+               handleSpecificImports(specificImports, source);
+      }
+      else if (defaultImport) {
+        return handleDefaultImports(defaultAs, defaultAsVar, defaultImport, source);
+      } else if (specificImports) {
+        return handleSpecificImports(specificImports, source);
+      }
+      return wholeMatch;
+    });
+}
+
+function handleSpecificImports(specificImports: string, source: string) {
+  specificImports = specificImports.replace(/ as /g, ': ');
+  return `const { ${specificImports} } = require(${source})`;
+}
+
+function handleDefaultImports(defaultAs: string, defaultAsVar: string, defaultImport: string, source: string) {
+  if (defaultAs) {
+    return `const ${defaultAsVar.trim()} = require(${source})`;
+  } else {
+    return `const ${defaultImport.trim()} = require(${source}).default`;
+  }
+}

src/register.ts

@@ -0,0 +1,17 @@
+import transform from './index';
+
+var fs = require('fs');
+
+var prev = require.extensions['.js'];
+
+require.extensions['.js'] = function(module: any, filename: string) {
+  if (filename.indexOf('node_modules') === -1) {
+    var source = fs.readFileSync(filename, 'utf8');
+    module._compile(transform(source), filename);
+  } else if (prev) {
+    prev(module, filename);
+  } else {
+    var source = fs.readFileSync(filename, 'utf8');
+    module._compile(source, filename);
+  }
+};

src/tests/transform_spec.ts

@@ -0,0 +1,67 @@
+import * as assert from 'assert';
+import transform from '../index';
+
+describe('transform', () => {
+  it('transforms named imports', () => {
+    const imp = "import 'Bar'";
+    assert.equal(transform(imp), "require('Bar')");
+
+    const imp1 = "import * as Foo from 'Bar'";
+    assert.equal(transform(imp1), "const Foo = require('Bar')");
+  });
+
+  it('transforms default imports', () => {
+    const imp = "import Foo from 'Bar'";
+    assert.equal(transform(imp), "const Foo = require('Bar').default");
+
+    const imp1 = "import * as Foo from 'Bar'";
+    assert.equal(transform(imp1), "const Foo = require('Bar')");
+  });
+
+  it('transforms named arguments', () => {
+    const imp = "import { Foo, Foo1 } from 'Bar'";
+    assert.equal(transform(imp), "const { Foo, Foo1 } = require('Bar')");
+
+    const imp1 = "import { Foo as Boo, Foo1 } from 'Bar'";
+    assert.equal(transform(imp1), "const { Foo: Boo, Foo1 } = require('Bar')");
+  });
+
+  it('transforms default and named arguments', () => {
+    const imp = "import Foo, { Foo1 } from 'Bar'";
+    assert.equal(transform(imp), "const Foo = require('Bar').default\nconst { Foo1 } = require('Bar')");
+
+    const imp1 = "import * as Foo { Foo1 } from 'Bar'";
+    assert.equal(transform(imp1), "const Foo = require('Bar')\nconst { Foo1 } = require('Bar')");
+  });
+
+  it('transforms exports', () => {
+    let imp = "export function m()";
+    assert.equal(transform(imp), "function m()\nexports.m = m;");
+  });
+
+  it('transforms multiple exports', () => {
+    let imp = `export function m()\nexport const n()`;
+    assert.equal(transform(imp), "function m()\nconst n()\nexports.m = m;\nexports.n = n;");
+  });
+
+  it('transforms default exports', () => {
+    let imp = `export default function m()\nexport const n()`;
+    assert.equal(transform(imp), "function m()\nconst n()\nexports.n = n;\nexports.default = m;");
+  });
+
+  it('transforms unnamed default exports', () => {
+    let imp = `export default function ()`;
+    assert.equal(transform(imp), "function defaultFunction()\nexports.default = defaultFunction;");
+
+    imp = `export default {`;
+    assert.equal(transform(imp), "const defaultObject = {\nexports.default = defaultObject;");
+
+    imp = `export default () =>`;
+    assert.equal(transform(imp), "const defaultFunction = () =>\nexports.default = defaultFunction;");
+  });
+
+  it('transforms default export variables', () => {
+    let imp = `export default m`;
+    assert.equal(transform(imp), "m\nexports.default = m;");
+  });
+});

src/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compileOnSave": true,
+  "compilerOptions": {
+    "target": "es5",
+    "module": "commonjs",
+    "declaration": false,
+    "noImplicitAny": true,
+    "removeComments": true,
+    "noLib": false,
+    "preserveConstEnums": true,
+    "outDir": "../dist",
+    "suppressImplicitAnyIndexErrors": true,
+    "experimentalDecorators": true,
+    "sourceMap": false,
+    "allowSyntheticDefaultImports": true,
+    "moduleResolution": "classic",
+    "allowJs": true,
+    "strictNullChecks": false
+  },
+  "filesGlob": [
+    "**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}

src/typings/globals/assert/index.d.ts

@@ -0,0 +1,57 @@
+// Generated by typings
+// Source: https://raw.githubusercontent.com/DefinitelyTyped/DefinitelyTyped/7de6c3dd94feaeb21f20054b9f30d5dabc5efabd/assert/assert.d.ts
+declare function assert(value:any, message?:string):void;
+declare namespace assert {
+    export class AssertionError implements Error {
+        name:string;
+        message:string;
+        actual:any;
+        expected:any;
+        operator:string;
+        generatedMessage:boolean;
+
+        constructor(options?:{message?: string; actual?: any; expected?: any; operator?: string; stackStartFunction?: Function});
+    }
+
+    export function fail(actual?:any, expected?:any, message?:string, operator?:string):void;
+
+    export function ok(value:any, message?:string):void;
+
+    export function equal(actual:any, expected:any, message?:string):void;
+
+    export function notEqual(actual:any, expected:any, message?:string):void;
+
+    export function deepEqual(actual:any, expected:any, message?:string):void;
+
+    export function notDeepEqual(acutal:any, expected:any, message?:string):void;
+
+    export function strictEqual(actual:any, expected:any, message?:string):void;
+
+    export function notStrictEqual(actual:any, expected:any, message?:string):void;
+
+    export var throws:{
+        (block:Function, message?:string): void;
+        (block:Function, error:Function, message?:string): void;
+        (block:Function, error:RegExp, message?:string): void;
+        (block:Function, error:(err:any) => boolean, message?:string): void;
+    };
+
+    export var doesNotThrow:{
+        (block:Function, message?:string): void;
+        (block:Function, error:Function, message?:string): void;
+        (block:Function, error:RegExp, message?:string): void;
+        (block:Function, error:(err:any) => boolean, message?:string): void;
+    };
+
+    export function ifError(value:any):void;
+}
+
+// duplicate to node.d.ts
+// declare module "assert" {
+//     export = assert;
+// }
+
+// move to power-assert.d.ts. do not use this definition file.
+declare module "assert" {
+    export = assert;
+}