https://github.com/a-la/alamode

A Node.JS RegExp-based transpiler of source code.
https://github.com/a-la/alamode

babel ecmascript export import modules node nodejs transpiler

Last synced: 2 days ago
JSON representation

A Node.JS RegExp-based transpiler of source code.

• Host: GitHub
• URL: https://github.com/a-la/alamode
• Owner: a-la
• License: agpl-3.0
• Created: 2018-07-25T17:10:44.000Z (over 6 years ago)
• Default Branch: master
• Last Pushed: 2020-03-14T23:16:59.000Z (almost 5 years ago)
• Last Synced: 2024-12-14T14:18:24.615Z (25 days ago)
• Topics: babel, ecmascript, export, import, modules, node, nodejs, transpiler
• Language: JavaScript
• Homepage: https://alamode.cc
• Size: 1.49 MB
• Stars: 10
• Watchers: 2
• Forks: 1
• Open Issues: 7
• Metadata Files:
  • Readme: README.md
  • Changelog: CHANGELOG.md
  • License: LICENSE

Awesome Lists containing this project

README

        
# ÀLaMode

[![npm version](https://badge.fury.io/js/alamode.svg)](https://www.npmjs.com/package/alamode)

[![Build status](https://ci.appveyor.com/api/projects/status/owaagwyeh6b8pwc5?svg=true)](https://ci.appveyor.com/project/4r7d3c0/alamode)

![Node.js CI](https://github.com/a-la/alamode/workflows/Node.js%20CI/badge.svg)

_ÀLaMode_ is a RegExp-based transpiler of source code in _Node.JS_ that supports transpilation of `import` and `export` statements including source map for debugging, while keeping the original code pretty much the same (no _interop_ require). It also can transpile JSX (without source maps ATM and some minor limitations).

The package can be used via the [CLI](#CLI) to build packages, or via the [require hook](#require-hook) to transform modules on-the-fly.

> If you've tried it and are having trouble seeing `unknown keyword export`, check if your issue falls under the category described in the [troubleshooting](#troubleshooting). That's the single problem that we've seen after a year of using this software.

```

yarn add -D alamode

npm i --save-dev alamode

```



  



## Why ÀLaMode

ÀLaMode is a neat, fast, low-weight alternative to AST-based transpilers. If you only want `import` and `export` statements, don't disrespect yourself by continuing to use _Babel_, and make a switch to **ÀLaMode** today. What am I talking about? Read next.



  



### It's Neat

The source code is left pretty much intact, with line numbers preserved, and exports just being renamed to `module.export` while making sure to export the default module first if it is present. There is no need to come up with super-fancy solutions and try to build a rocket when all you need is a remote control. That means, don't worry about EcmaScript modules standard, it's significance is blown out of proportions by the "community" who has nothing better to do. Just rename exports to module.exports and imports to require — that's the philosophy behind _ÀLaMode_.

Source CodeTranspiled Code

```js

import Stream, {

  Transform,

} from 'stream'

import { join } from 'path'

export default class S extends Transform {

  /**

   * Creates a new instance.

   * @param {string} path

   * @param {Stream} [parent]

   */

  constructor(path, parent) {

    super()

    this.source = join('example', path)

    if (parent instanceof Stream)

      this.pipe(parent)

  }

}

/**

 * A function that returns `c`.

 * @param {string} input

 */

export const c = (input = '') => {

  return 'c' + input ? `-${input}` : ''

}

/**

 * A function that returns `b`.

 * @param {number} times

 */

export const b = (times = 0) => {

  return 'b' + times ? `-${times}` : ''

}

```

```

```

```js

const Stream = require('stream'); const {

  Transform,

} = Stream;

const { join } = require('path');

class S extends Transform {

  /**

   * Creates a new instance.

   * @param {string} path

   * @param {Stream} [parent]

   */

  constructor(path, parent) {

    super()

    this.source = join('example', path)

    if (parent instanceof Stream)

      this.pipe(parent)

  }

}

/**

 * A function that returns `c`.

 * @param {string} input

 */

const c = (input = '') => {

  return 'c' + input ? `-${input}` : ''

}

/**

 * A function that returns `b`.

 * @param {number} times

 */

const b = (times = 0) => {

  return 'b' + times ? `-${times}` : ''

}

module.exports = S

module.exports.c = c

module.exports.b = b

```

Show Babel Output

```js

"use strict";

Object.defineProperty(exports, "__esModule", {

  value: true

});

exports.b = exports.c = exports.default = void 0;

var _stream = _interopRequireWildcard(require("stream"));

var _path = require("path");

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { var desc = Object.defineProperty && Object.getOwnPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : {}; if (desc.get || desc.set) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } } newObj.default = obj; return newObj; } }

class S extends _stream.Transform {

  /**

   * Creates a new instance.

   * @param {string} path

   * @param {Stream} [parent]

   */

  constructor(path, parent) {

    super();

    this.source = (0, _path.join)('example', path);

    if (parent instanceof _stream.default) this.pipe(parent);

  }

}

/**

 * A function that returns `c`.

 * @param {string} input

 */

exports.default = S;

const c = (input = '') => {

  return 'c' + input ? `-${input}` : '';

};

/**

 * A function that returns `b`.

 * @param {number} times

 */

exports.c = c;

const b = (times = 0) => {

  return 'b' + times ? `-${times}` : '';

};

exports.b = b;

```



  



### It Has 0 Dependencies

ÀLaMode does not install any additional dependencies, and it has been optimised with _Google Closure Compiler_. That means you don't have to wait ages for each new real dependency in your project to link with Babel's bloatware you don't care about. Just focus on the work and enjoy the single new directory in your `node_modules`.

ÀLaMode: 8 yarn.lock linesBabel: 1650 yarn.lock Lines







  



### It Respects JSDoc

Let's face it, _Babel_ is software for masses that has capitalized on people's vulnerability in wanting to use `import` and `export` statements which is one of the best features on the language. You say let them be, I say look what they are doing to your documented code without caring a single bit:

ÀLaMode: Gold StandardBabel: JSDoc Enemy





Original Source:

```js

/**

 * A function that returns `b`.

 * @param {number} times

 */

export const b = (times) => {

  return 'b' + (times ? `-${times}` : '')

}

```

See if you can figure out [why this happens](https://github.com/a-la/fixture-babel/blob/master/build/index.js#L31). Unlike _Babel_, our [Node.JS Development Company](https://artd.eco) cares about quality and developer experience, so we're offering ÀLaMode as a simple and lightweight solution to transpile packages.



  



## Table Of Contents

- [Why ÀLaMode](#why-àlamode)

  * [It's Neat](#its-neat)

  * [It Has 0 Dependencies](#it-has-0-dependencies)

  * [It Respects JSDoc](#it-respects-jsdoc)

- [Table Of Contents](#table-of-contents)

- [Installation](#installation)

  * [Global](#global)

  * [Project](#project)

- [CLI](#cli)

  * [`NODE_DEBUG`](#node_debug)

  * [`--help`](#--help)

- [Compiling JSX: `--jsx, --preact`](#compiling-jsx---jsx---preact)

  * [CSS Injector](#css-injector)

- [ÀLaNode](#àlanode)

- [.alamoderc.json](#alamodercjson)

- [Transforms](#transforms)

- [Require Hook](#require-hook)

  * [`_alamode.HookConfig`](#type-_alamodehookconfig)

  * [Multiple Calls To Alamode()](#multiple-calls-to-alamode)

- [Source Maps](#source-maps)

  * [debug session](#debug-session)

- [Troubleshooting](#troubleshooting)

- [Copyright & License](#copyright--license)



  



## Installation

The software can be installed either as a global dependency, or as a project dependency.

### Global

When installed globally, it will be used directly via a binary, such as `alamode src -o build`.

|                                      Package Manager                                      |       Installation        |

| ----------------------------------------------------------------------------------------- | ------------------------- |

|  npm     | `npm i -g alamode` |

|  yarn | `yarn add global alamode` |

### Project

When installed in a project, it will be used via the `package.json` script, e.g., `yarn build` or `npm run build`.

```json5

{

  "name": "project",

  "version": "1.0.0",

  "description": "An example project",

  "main": "build",

  "scripts": {

    "build": "alamode src -o build"

  },

  "files": ["build"],

  "license": "MIT"

}

```

|                                      Package Manager                                      |        Installation        |

| ----------------------------------------------------------------------------------------- | -------------------------- |

|  npm     | `npm i --save-dev alamode` |

|  yarn | `yarn add -DE alamode` |



  



## CLI

The binary accepts a path to a single file, or a directory with the source code as the first argument, and a path to the build folder via `-o` argument.

```sh

alamode src -o build

```

There are other arguments which can be passed.

 

  

   Argument 

   Short

   Description

  

 

  

   source

   

   The location of the input file or directory to transpile.

  

  

   --output

   -o

   The location of where to save the transpiled output.

  

  

   --ignore

   -i

   Comma-separated list of files inside of source dir to

    ignore, for example, bin,.eslintrc.

  

  

   --noSourceMaps

   -s

   Disable source maps.

  

  

   --extensions

   -e

   Files of what extensions to transpile. Default js,jsx.

  

  

   --debug

   -d

   Will make ÀLaMode stop after replacing markers.

  

  

   --require

   -r

   Renames require calls into imports, and module.exports

    assignments to exports.

    Great for refactoring older code.

  

  

   --env

   

   The environment. Analogue to setting ALAMODE_ENV

    env variable.

  

  

   --version

   -v

   Show the version number.

  

  

   --help

   -h

   Display the usage information.

  

Additional JSX options are also available:

 

  

   Argument 

   Short

   Description

  

 

  

   --jsx

   -j

   Enable JSX mode: only update JSX syntax to use hyperscript.

    Does not transpile import/export statements.

  

  

   --module

   -m

   Works together with jsx to also transpile modules while

    transpiling JSX.

  

  

   --preact

   -p

   When transpiling JSX, automatically insert at the top

    import { h } from "preact".

  

  

   --preact-externs

   -E

   Same as preact, but imports from ＠externs/preact

    import { h } from "＠externs/preact".

  

Setting the `NODE_DEBUG` environmental variable to `alamode` will print the list of processed files to the `stderr`.

```sh

$ NODE_DEBUG=alamode alamode src -o build -i bin/alamode.js

```

```fs

ALAMODE 97955: index.js

ALAMODE 97955: bin/catcher.js

ALAMODE 97955: bin/index.js

ALAMODE 97955: lib/index.js

```



  



### `--help`

Shows all available commands.

```

ÀLaMode

A tool to transpile JavaScript packages using regular expressions.

Supports import/export and JSX transpilation.

https://artdecocode.com/alamode/

  alamode source [-o destination] [-i dir,file] [--env env] [-s]

	source            	The location of the input file or directory to transpile.

	--output, -o      	The location of where to save the transpiled output.

	--ignore, -i      	Comma-separated list of files inside of `source` dir to

	                  	ignore, for example, `bin,.eslintrc`.

	--noSourceMaps, -s	Disable source maps.

	--extensions, -e  	Files of what extensions to transpile.

	                  	Default: js,jsx.

	--debug, -d       	Will make ÀLaMode stop after replacing markers.

	--require, -r     	Renames `require` calls into imports, and `module.exports`

	                  	assignments to exports.

	                  	Great for refactoring older code.

	--env             	The environment. Analogue to setting `ALAMODE_ENV`

	                  	env variable.

	--version, -v     	Show the version number.

	--help, -h        	Display the usage information.

  Example:

    alamode src -o build -s

JSX transpilation

Allows to transpile JSX using RegExes.

  alamode source [-o destination] -j [-mpE]

	--jsx, -j           	Enable JSX mode: only update JSX syntax to use hyperscript.

	                    	Does not transpile `import/export` statements.

	--module, -m        	Works together with `jsx` to also transpile modules while

	                    	transpiling JSX.

	--preact, -p        	When transpiling JSX, automatically insert at the top

	                    	`import { h } from "preact"`.

	--preact-externs, -E	Same as `preact`, but imports from `＠externs/preact`

	                    	`import { h } from "＠externs/preact"`.

  Example:

    alamode src -o build -j -m

```



  



## Compiling JSX: `--jsx, --preact`

ÀLaMode can transpile JSX syntax. In the `jsx` mode, the `import/export` statements will be left intact, but the source code will be transformed to add pragma invocations, such as `h(Component, { props }, children)`. The default pragma is `h` for Preact, and to avoid writing `import { h } from 'preact'` in each file, the `-p` option can be passed for ÀLaMode to add it automatically.

_For example, the following file can be compiled:_

```jsx

import { render } from 'preact'

const Component = ({ test, ...props }) => (

  


    {test}

  

)

render(Example, document.body)

```


_Using the `alamode example/index.jsx -j -p` command:_

```js

import { h } from 'preact'

import { render } from 'preact'

const Component = ({ test, ...props }) => (

   h('div',{...props,'id':"example"},

    test,

  )

)

render( h(Component,{cool:true},`Example`), document.body)

```



  



### CSS Injector

_ÀLaMode_ can transpile the `import './style.css'` directives into `import './style.css.js'`, where `style.css.js` becomes a module with a css-injector script that will add your CSS to the `head` element.



  



## ÀLaNode

To be able to spawn modules without having to create a proxy file as below:

```js

require('alamode')()

require('./package')

```

ÀLaMode bundles a binary called `alanode`. It will do the same thing as above, so that running modules with `import` and `export` statements becomes really easy.

```sh

$ alanode source

```

It changes `import` and `export` statements into `require` calls and `module.export` expressions. It also normalises `process.argv` to hide its presence, so that programs can safely keep using the _argv_ array without unexpected results.

_With the following file that uses an import_:

```js

import { constants } from 'os'

import { basename } from 'path'

console.log(basename(process.argv[1]))

console.log(constants.signals.SIGINT)

```

_`$ alanode t` will generate the result successfully:_

```

t

2

```



ÀLaNode is also available as a standalone package `alanode`.


[![npm version](https://badge.fury.io/js/alanode.svg)](https://www.npmjs.com/package/alanode)





  



## .alamoderc.json

A transform can support options which are set in the `.alamoderc.json` configuration file. The configuration file is read from the same directory where the program is executed (cwd). Options inside of the `env` directive will be active only when the `ALAMODE_ENV` environmental variable is set to the `env` key.

```json

{

  "env": {

    "test-build": {

      "import": {

        "replacement": {

          "from": "^((../)+)src",

          "to": "$1build"

        }

      }

    }

  },

  "import": {

    "alamodeModules": ["alamode", "example"],

    "stdlib": {

      "path": "stdlib.js",

      "packages": ["example"]

    }

  }

}

```



  



## Transforms

The main import and export transforms are included as part of _ÀLaMode_.

- 📥[`@a-la/import`](../../wiki/Import) Changes imports to requires. Read _Wiki_ for additional options and guidance on how to test builds and build source code to use the standard library compiled out of all dependencies using [_Depack_](https://github.com/dpck/depack#standard-library).

- 📤[`@a-la/export`](../../wiki/Export) Updates `export` to `module.exports` while preserving whitespace for human-readable output.



  



## Require Hook

The purpose of the require hook is to be able to transpile files automatically when they are imported.

To use this feature, `alamode` needs to be `required` in a separate file, after which the `import` and `export` statements will become available.

For example, take the following directory structure, with a main and library files:

```m

example/require

├── debug.js

├── index.js

├── lib.js

├── multiple.js

└── require.js

```

index.js

lib.js

```js

import getInfo from './lib'

console.log(getInfo())

```

```js

import { platform, arch } from 'os'

export default () => {

  return `${platform()}:${arch()}`

}

```

The require hook would work in the following way:

```js

require('alamode')()

require('.')

```

By executing the `node require.js` command, `alamode` will be installed and it will do its job dynamically for every `.js` file that is required, enabling to use `import` and `export` statements.

```

darwin:x64

```

`_alamode.HookConfig`: The options for ÀLaMode Hook.

|       Name        |                Type                |                                           Description                                            | Default |

| ----------------- | ---------------------------------- | ------------------------------------------------------------------------------------------------ | ------- |

| pragma            | string                    | What pragma to add on top of JSX programs. Default `const { h } = require('preact');`.           | -       |

| noWarning         | boolean                   | Disable warnings when resetting existing hooks.                                                  | `false` |

| ignoreNodeModules | boolean                   | Auto-ignore node_modules. Independent of any matcher.                                            | `true`  |

| matcher           | (path: string) => boolean | The function that will be called with the path and return whether the file should be transpiled. | -       |



  



### Multiple Calls To Alamode()

When the call is made multiple times in the program, the latter calls will revert the previous hooks and install new ones. The warning will be shown unless the `noWarning` option is set to true.

```js

const alamode = require('alamode')

alamode()

// in other file

const path = require('path')

const preact = path.relative('', path

  .dirname(require.resolve('preact/package.json')))

alamode({

  pragma: `const { h } = require("./${preact}");`,

  // noWarning: true, // to disable output

})

```

```

Reverting JS hook to add new one.

Reverting JSX hook to add new one, pragma:

const { h } = require("./node_modules/preact");

```

This can happen when the tests are set up to run with _Zoroaster_ with the `-a` flag for alamode, and the source code also tries to install the require hook.



  



## Source Maps

The source maps are supported by this package, but implemented in a hack-ish way. The transforms will aim to preserve line and column numbers, so that no additional remapping is required. However this is not enough to generate a source map good enough for a debugger -- it needs to know about mappings of positions between segments which can be operators, function calls, _etc_. `alamode` simply breaks the source code into distinct chunks such as white-spaces, identifiers and comments, and down into individual symbols. Using this method, the size of a source map is larger, but it still works. In further versions, this will be improved to allow to extract real segments.

[![source map visualistion](doc/sourcemap.gif)](http://sokra.github.io/source-map-visualization/#base64,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,{"version":3,"sources":["../../src/bin/transpile.js"],"names":[],"mappings":"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","file":"bin/transpile.js","sourcesContent":["import { join, basename, dirname } from 'path'\nimport { lstatSync } from 'fs'\nimport readDirStructure from '@wrote/read-dir-structure'\nimport ensurePath from '@wrote/ensure-path'\nimport { debuglog } from 'util'\nimport { copyMode } from '../lib'\nimport writeSourceMap from '../lib/source-map'\nimport { transformStream } from '../lib/transform'\n\nconst LOG = debuglog('alamode')\n\nconst processFile = async ({\n  input, relPath, name, output, ignore, noSourceMaps,\n}) => {\n  const file = join(relPath, name)\n  if (ignore.includes(file)) return\n\n  const isOutputStdout = output == '-'\n  const source = join(input, file)\n\n  const outputDir = isOutputStdout ? null : join(output, relPath)\n  const destination = isOutputStdout ? '-' : join(outputDir, name)\n  LOG(file)\n\n  await ensurePath(destination)\n\n  const originalSource = await transformStream({\n    source,\n    destination,\n  })\n\n  if (output != '-') {\n    copyMode(source, destination)\n    if (noSourceMaps) return\n    writeSourceMap({\n      destination,\n      file,\n      name,\n      outputDir,\n      source,\n      originalSource,\n    })\n  }\n}\n\nconst processDir = async ({\n  input,\n  output,\n  relPath = '.',\n  ignore = [],\n  noSourceMaps,\n}) => {\n  const path = join(input, relPath)\n  const { content } = await readDirStructure(path)\n  const k = Object.keys(content)\n  await k.reduce(async (acc, name) => {\n    await acc\n    const { type } = content[name]\n    if (type == 'File') {\n      await processFile({\n        input, relPath, name, output, ignore, noSourceMaps,\n      })\n    } else if (type == 'Directory') {\n      const newRelPath = join(relPath, name)\n      await processDir({\n        input,\n        output,\n        ignore,\n        relPath: newRelPath,\n        noSourceMaps,\n      })\n    }\n  }, Promise.resolve())\n}\n\nexport const transpile = async ({\n  input,\n  output = '-',\n  ignore = [],\n  noSourceMaps,\n}) => {\n  if (!input) throw new Error('Please specify the source file or directory.')\n\n  const ls = lstatSync(input)\n  if (ls.isDirectory()) {\n    if (!output) throw new Error('Please specify the output directory.')\n    await processDir({\n      input,\n      output,\n      ignore,\n      noSourceMaps,\n    })\n  } else if (ls.isFile()) {\n    await processFile({\n      input: dirname(input),\n      relPath: '.',\n      name: basename(input),\n      output,\n      ignore,\n      noSourceMaps,\n    })\n  }\n  if (output != '-') process.stdout.write(`Transpiled code saved to ${output}\\n`)\n}\n"]},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)

  Click to View: debug session

  

  

    

  

  



  



## Troubleshooting

Because there can be many intricacies when transpiling with regular expressions, problems might arise from time to time. If using the `require` hook, the best solution is to build the source code using `alamode` binary, and see where the error occurs. Then it must be analysed why it happens, for example:

- The `import` or `export` transform does not match the case.

- A portion of source code is cut out before the transform with [`markers`](https://github.com/a-la/markers/blob/master/src/index.js#L46) so that the line does not participate in a transform.

So the single most common problem that we've experienced, is using the `//` and `/*` inside string literals (`), e.g.,

```js

const host = 'localhost'

const port = 9999

const url = `https://${host}:${port}`

export const test = 'hello world'

const otherUrl = `https://${host}:${port}`

```

```

example/trouble.js:5

export const test = 'hello world'

^^^^^^

SyntaxError: Unexpected token export

    at createScript (vm.js:80:10)

    at Object.runInThisContext (vm.js:139:10)

    at Module._compile (module.js:617:28)

    at Module.p._compile (node_modules/alamode/compile/depack.js:49:18)

    at Module._extensions..js (module.js:664:10)

    at Object.k.(anonymous function).y._extensions.(anonymous function) [as .js] (node_modules/alamode/compile/depack.js:51:7)

    at Module.load (module.js:566:32)

    at tryModuleLoad (module.js:506:12)

    at Function.Module._load (module.js:498:3)

    at Module.require (module.js:597:17)

```

This is because //${host}:${port}` will be cut until the end of the line as a comment prior to the template, and the template will match until the next opening backtick rather than the correct one, taking out the export from the transformation. To validate that, we can run the alamode src -d command:

```

const host = %%_RESTREAM_STRINGS_REPLACEMENT_0_%%

const port = 9999

const url = %%_RESTREAM_LITERALS_REPLACEMENT_0_%%https:%%_RESTREAM_INLINECOMMENTS_REPLACEMENT_1_%%

```

Now to fix this issue, either use `'` to concatenate strings that have `/*` and `//`, or use `import { format } from 'url'` to dynamically create addresses.



  



## Copyright & License

GNU Affero General Public License v3.0

You CAN use the require hook for your own code without publishing the source code. For example, you CAN run a web-server where your source code is transpiled on-the-fly. On the other hand, you're not allowed to build other software packages that link to _ÀLaMode_ to enable transpilation feature for your users without adhering to **Affero**.

Affero is better for Open Source anyway, why don't you consider it instead of MIT.

  

    

      

        

      

    

    © Art Deco™ for À La Mode 2020