requirejs-esm 2.0.1 → 2.2.1

package/src/transformer/converters.js

@@ -0,0 +1,102 @@
+import {
+  identifier, memberExpression, assignmentExpression, expressionStatement
+} from './factories'
+import { isValidIdentifier } from './validators'
+import { isIdentifierChar } from './identifier'
+
+export function toIdentifier(input) {
+  input = input + ''
+
+  let name = ''
+  for (const c of input) {
+    name += isIdentifierChar(c.codePointAt(0)) ? c : '-'
+  }
+
+  name = name.replace(/^[-0-9]+/, '')
+
+  name = name.replace(/[-\s]+(.)?/g, function (match, c) {
+    return c ? c.toUpperCase() : ''
+  })
+
+  if (!isValidIdentifier(name)) {
+    name = `_${name}`
+  }
+
+  return name || '_'
+}
+
+export function toExpression(node) {
+  if (node.type === 'ExpressionStatement') {
+    node = node.expression
+  }
+
+  const { type } = node
+
+  if (type.endsWith('Expression')) return node
+
+  if (type === 'ClassDeclaration') {
+    node.type = 'ClassExpression'
+  } else if (type === 'FunctionDeclaration') {
+    node.type = 'FunctionExpression'
+  }
+
+  if (!node.type.endsWith('Expression')) {
+    throw new Error(`cannot turn ${node.type} to an expression`)
+  }
+
+  return node
+}
+
+export function toStatement(node, ignore) {
+  const { type } = node
+
+  if (type.endsWith('Statement')) return node
+
+  let mustHaveId = false
+  let newType
+
+  if (type === 'ClassDeclaration' || type === 'ClassExpression') {
+    mustHaveId = true
+    newType = 'ClassDeclaration'
+  } else if (type === 'FunctionDeclaration' || type === 'FunctionExpression' ||
+             type === 'ArrowFunctionExpression') {
+    mustHaveId = true
+    newType = 'FunctionDeclaration'
+  } else if (type === 'AssignmentExpression') {
+    return expressionStatement(node)
+  }
+
+  if (mustHaveId && !node.id) {
+    newType = false
+  }
+
+  if (!newType) {
+    if (ignore) {
+      return false
+    } else {
+      throw new Error(`cannot turn ${node.type} to a statement`)
+    }
+  }
+
+  node.type = newType
+
+  return node
+}
+
+export function replaceLiteral(literal, value) {
+  literal.value = value
+  const { raw } = literal
+  if (raw === undefined) return
+  if (typeof value === 'string') {
+    literal.raw = String(raw).charAt(0) === "'" ?
+      `'${value.replaceAll("'", "\\'")}'` : `"${value.replaceAll('"', '\\"')}"`
+  } else {
+    literal.raw = String(value)
+  }
+}
+
+// Returns a statement assigning a property value to the exports object.
+export function exportStatement(exportsVar, key, value) {
+  return toStatement(assignmentExpression('=',
+    memberExpression(exportsVar, identifier(key)), value))
+}

package/src/transformer/esm.js

@@ -0,0 +1,367 @@
+import { isAnonymousImport, isImportDefault, isImportAllAs } from './validators'
+import {
+  identifier, memberExpression, objectExpression, arrayExpression, blockStatement,
+  variableDeclaration, variableDeclarator, returnStatement, expressionStatement,
+  forInStatement, assignmentExpression, callExpression, functionExpression
+} from './factories'
+import { toExpression, replaceLiteral, exportStatement } from './converters'
+import { generateUid, generateUidIdentifier } from './generate-id'
+
+// Detects if a program contains import statements.
+// Returns information about the import statemets [{ node, source, specifiers|local }, ...] or [].
+export function detectImportsAndExports(program) {
+  const { body } = program
+  const { length } = body
+
+  const imports = []
+  const exports = []
+
+  for (let i = 0; i < length; ++i) {
+    const node = body[i]
+
+    // import
+    if (node.type === 'ImportDeclaration') {
+      const { source } = node
+
+      // import "some"
+      if (isAnonymousImport(node)) {
+        imports.push({ node, source })
+      }
+      // import some from "some"
+      // import * as some from "some"
+      else if (isImportDefault(node) || isImportAllAs(node)) {
+        const { local } = node.specifiers[0]
+        imports.push({ node, source, local })
+      }
+      // import {x, y, z} from "xyz"
+      else {
+        const specifiers = node.specifiers.map(({ imported, local }) => ({ imported, local }))
+        imports.push({ node, source, specifiers })
+      }
+    }
+
+    // export default
+    else if (node.type === 'ExportDefaultDeclaration') {
+      exports.push({ node, default: true })
+    }
+
+    // export {x as y}
+    // export var a = 1
+    // export function test() {}
+    // export class Test {}
+    else if (node.type === 'ExportNamedDeclaration') {
+      const { specifiers } = node
+
+      // export var a = 1
+      if (!specifiers.length) {
+        exports.push({ node })
+      } else { // export {x as y}
+        // export { ... } from "module"
+        const { source } = node
+        if (source) {
+          exports.push({ node, source, import: true })
+          const specifiers = node.specifiers.map(({ exported: imported, local }) => ({ imported, local }))
+          imports.push({ node, source, specifiers, export: true })
+        } else {
+          exports.push({ node })
+        }
+      }
+    }
+
+    // export * from "module"
+    if (node.type === 'ExportAllDeclaration') {
+      exports.push({ node, import: true })
+      const { source } = node
+      imports.push({ node, source, export: true })
+    }
+  }
+
+  return { imports, exports }
+}
+
+// Transforms the module format from ESM to AMD.
+export function transformEsmToAmd(program, options) {
+  const { body } = program
+  let { length } = body
+
+  const importPaths = []
+  const importVars = []
+  const namedImports = []
+  const localImports = new Set()
+
+  const exportsVar = generateUidIdentifier('exports', program, program)
+  let hasExport = false
+  let needReturnExport = false
+  let isOnlyDefaultExport = true
+
+  for (let i = 0; i < length; ++i) {
+    const statement = body[i]
+
+    // import
+    if (statement.type === 'ImportDeclaration') {
+      // save import path
+      const exportSource = statement.source
+      importPaths.push(exportSource)
+
+      const importNode = statement
+      // import "some"
+      if (isAnonymousImport(importNode)) {
+        // importVars.length should be equal importPaths.length
+        const importVar = generateUidIdentifier(exportSource.value, program)
+        importVars.push(importVar)
+      }
+      // import some from "some"
+      // import * as some from "some"
+      else if (isImportDefault(importNode) || isImportAllAs(importNode)) {
+        const asName = importNode.specifiers[0].local
+        importVars.push(asName)
+      }
+      // import {x, y, z} from "xyz"
+      else {
+        // convert "/path/to/a" to _pathToA
+        const asName = generateUidIdentifier(exportSource.value, program)
+        importVars.push(asName)
+
+        for (const { imported, local } of importNode.specifiers) {
+          const { name } = local
+          localImports.add(name)
+          namedImports.push(declareImport(name, asName.name, imported.name))
+        }
+      }
+
+      body.splice(i--, 1)
+      --length
+    }
+
+    // export default
+    if (statement.type === 'ExportDefaultDeclaration') {
+      // need return at end file
+      hasExport = true
+      needReturnExport = true
+
+      // expression after keyword default
+      const { declaration } = statement
+      let exportValue = declaration
+      let needExportExpression = true
+
+      if (declaration.type === 'FunctionDeclaration') {
+        exportValue = toExpression(exportValue)
+      }
+      if (declaration.type === 'ClassDeclaration') {
+        exportValue = toExpression(exportValue)
+        // const classNode = exportValue
+
+        // if (classNode.id) {
+        //   body[i] = classNode
+
+        //   const className = identifier(classNode.id.name)
+        //   let exportStat
+        //   if (i + 1 === length && isOnlyDefaultExport) {
+        //     exportStat = returnStatement(identifier(className))
+        //     needReturnExport = false
+        //   } else {
+        //     exportStat = exportStatement(exportsVar, 'default', className)
+        //   }
+
+        //   program.pushContainer('body', [exportStat])
+        //   needExportExpression = false
+        // } else {
+        //   exportValue = toExpression(classNode)
+        // }
+      }
+
+      if (needExportExpression) {
+        let exportStat
+
+        if (i + 1 === length && isOnlyDefaultExport) {
+          exportStat = returnStatement(exportValue)
+          needReturnExport = false
+        } else {
+          exportStat = exportStatement(exportsVar, 'default', exportValue)
+        }
+
+        body[i] = exportStat
+      }
+    }
+
+    // export {x as y}
+    // export var a = 1
+    // export function test() {}
+    // export class Test {}
+    if (statement.type === 'ExportNamedDeclaration') {
+      hasExport = true
+      needReturnExport = true
+
+      const { specifiers, declaration } = statement
+
+      // export var a = 1
+      if (!specifiers.length) {
+        isOnlyDefaultExport = false
+
+        // replace "export <expression>"
+        // to "<expression>"
+        body[i] = declaration
+
+        // export var a = 1, b = 2
+        if (declaration.type === 'VariableDeclaration') {
+          for (const { id } of declaration.declarations) {
+            const { name } = id
+            const exportStat = exportStatement(exportsVar, name, identifier(name))
+            body.push(exportStat)
+          }
+        }
+
+        // export function x() {}
+        if (declaration.type === 'FunctionDeclaration') {
+          const asName = declaration.id.name
+
+          const exportStat = exportStatement(exportsVar, asName, identifier(asName))
+          body.push(exportStat)
+        }
+
+        // export class Test {}
+        if (declaration.type === 'ClassDeclaration') {
+          const asName = declaration.id.name
+
+          const exportStat = exportStatement(exportsVar, asName, identifier(asName))
+          body.push(exportStat)
+        }
+      } else { // export {x as y}
+        // export { ... } from "module"
+        const exportSource = statement.source
+        if (exportSource) {
+          // save import path
+          importPaths.push(exportSource)
+          // importVars.length should be equal importPaths.length
+          const importVar = generateUidIdentifier(exportSource.value, program)
+          importVars.push(importVar)
+
+          for (let specifier of specifiers) {
+            const { exported, local } = specifier
+            const { name } = local
+            let localName
+            // newly re-exporting earlier imported identifier
+            if (localImports.has(name)) {
+              localName = generateUid(name, program)
+              addExportStatement({ exported, local: identifier(localName) })
+            } else {
+              localName = name
+              addExportStatement(specifier)
+            }
+            namedImports.push(declareImport(localName, importVar.name, name))
+          }
+        } else {
+          for (const specifier of specifiers) {
+            addExportStatement(specifier)
+          }
+        }
+
+        body.splice(i--, 1)
+        --length
+      }
+    }
+
+    // export * from "module"
+    if (statement.type === 'ExportAllDeclaration') {
+      isOnlyDefaultExport = false
+      hasExport = true
+      needReturnExport = true
+
+      // save import path
+      const exportSource = statement.source
+      importPaths.push(exportSource)
+      // importVars.length should be equal importPaths.length
+      const importVar = generateUidIdentifier(exportSource.value, program)
+      importVars.push(importVar)
+
+      body[i] = exportCopyLoop(exportsVar, importVar)
+    }
+  }
+
+  // adding define wrapper
+  if (hasExport && needReturnExport) {
+    // var _exports = {}
+    body.unshift(
+      variableDeclaration('let', [
+        variableDeclarator(exportsVar, objectExpression([]))
+      ])
+    )
+
+    // return <expression>
+    let returnStat
+    if (isOnlyDefaultExport) {
+      // return _exports.default
+      returnStat = returnStatement(memberExpression(exportsVar, identifier('default')))
+    }
+    else {
+      // return _exports
+      returnStat = returnStatement(exportsVar)
+    }
+
+    body.push(returnStat)
+  }
+
+  buildAmdModule(program, options, importPaths, importVars, namedImports)
+
+  function addExportStatement({ exported, local }) {
+    const asName = exported.name
+    if (asName !== 'default') {
+      isOnlyDefaultExport = false
+    }
+    const exportStat = exportStatement(exportsVar, asName, local)
+    body.push(exportStat)
+  }
+}
+
+function declareImport(varName, object, property) {
+  return variableDeclaration('let', [
+    variableDeclarator(
+      identifier(varName),
+      memberExpression(identifier(object), identifier(property))
+    )
+  ])
+}
+
+function exportCopyLoop(exportsVar, importVar) {
+  const key = identifier('_key')
+  return forInStatement(
+    variableDeclaration('const', [variableDeclarator(key)]),
+    importVar,
+    blockStatement([
+      expressionStatement(
+        assignmentExpression('=',
+          memberExpression(exportsVar, key, true), memberExpression(importVar, key, true)))
+    ])
+  )
+}
+
+// Wraps a program body of statements into an AMD module.
+function buildAmdModule(program, options, importPaths, importVars, namedImports) {
+  program.body = [
+    expressionStatement(callExpression(
+      identifier('define'), importPaths.length ? [
+        prepareImportPaths(importPaths, options),
+        functionExpression(importVars, blockStatement(namedImports.concat(program.body)))
+      ] : [
+        functionExpression([], blockStatement(program.body))
+      ]))
+  ]
+}
+
+// Update dependency paths to be prefixed by `esm!` or otherwise updated.
+function prepareImportPaths(importPaths, options ) {
+  const { resolvePath } = options
+  if (resolvePath) {
+    const { sourceFileName: parentName } = options
+    for (const importPath of importPaths) {
+      if (importPath.type === 'Literal') {
+        const moduleName = importPath.value
+        const newModuleName = resolvePath(moduleName, parentName, options)
+        if (newModuleName && newModuleName !== moduleName) {
+          replaceLiteral(importPath, newModuleName)
+        }
+      }
+    }
+  }
+  return arrayExpression(importPaths)
+}

package/src/transformer/factories.js

@@ -0,0 +1,55 @@
+export function literal(value) {
+  return { type: 'Literal', value }
+}
+
+export function identifier(name) {
+  return { type: 'Identifier', name }
+}
+
+export function memberExpression(object, property, computed) {
+  return { type: 'MemberExpression', object, property, computed }
+}
+
+export function objectExpression(properties) {
+  return { type: 'ObjectExpression', properties }
+}
+
+export function arrayExpression(elements) {
+  return { type: 'ArrayExpression', elements }
+}
+
+export function assignmentExpression(operator, left, right) {
+  return { type: 'AssignmentExpression', operator, left, right }
+}
+
+export function variableDeclaration(kind, declarations) {
+  return { type: 'VariableDeclaration', kind, declarations }
+}
+
+export function variableDeclarator(id, init) {
+  return { type: 'VariableDeclarator', id, init }
+}
+
+export function expressionStatement(expression) {
+  return { type: 'ExpressionStatement', expression }
+}
+
+export function returnStatement(argument) {
+  return { type: 'ReturnStatement', argument }
+}
+
+export function forInStatement(left, right, body) {
+  return { type: 'ForInStatement', left, right, body }
+}
+
+export function blockStatement(body) {
+  return { type: 'BlockStatement', body }
+}
+
+export function callExpression(callee, args) {
+  return { type: 'CallExpression', callee, arguments: args }
+}
+
+export function functionExpression(params, body) {
+  return { type: 'FunctionExpression', params, body }
+}

package/src/transformer/generate-id.js

@@ -0,0 +1,96 @@
+import { isAnonymousImport, isImportDefault, isImportAllAs } from './validators'
+import { identifier } from './factories'
+import { toIdentifier } from './converters'
+
+function _generateUid(name, i) {
+  let id = name
+  if (i > 1) id += i
+  return `_${id}`
+}
+
+function getUids(program) {
+  const uids = new Set()
+  for (const statement of program.body) {
+    const { type } = statement
+    if (type === 'LabeledStatement') {
+      const { label } = statement
+      if (label) {
+        uids.add(label.name)
+      }
+    } else if (type === 'ImportDeclaration') {
+      // import some from "some"
+      // import * as some from "some"
+      if (isImportDefault(statement) || isImportAllAs(statement)) {
+        uids.add(statement.specifiers[0].local.name)
+      }
+      // import {x, y, z} from "xyz"
+      else if (!isAnonymousImport(statement)) {
+        for (const { local } of statement.specifiers) {
+          uids.add(local.name)
+        }
+      }
+    } else if (type === 'ExportNamedDeclaration') {
+      const { declaration } = statement
+      if (declaration) {
+      const { type } = declaration
+        // export var a = 1
+        if (type === 'VariableDeclaration') {
+          for (const { id } of declaration.declarations) {
+            uids.add(id.name)
+          }
+        }
+        // export function test() {}
+        // export class Test {}
+        else if (type === 'FunctionDeclaration' || type === 'ClassDeclaration') {
+          uids.add(declaration.id.name)
+        }
+        // export {x as y}
+        else {
+          for (const { local } of statement.specifiers) {
+            uids.add(local.name)
+          }
+        }
+      }
+    } else if (type === 'VariableDeclaration') {
+      for (const { id } of statement.declarations) {
+        if (id.type === 'Identifier') {
+          uids.add(id.name)
+        } else {
+          for (const { value } of id.properties) {
+            uids.add(value.name)
+          }
+        }
+      }
+    } else if (type === 'FunctionDeclaration' || type === 'ClassDeclaration') {
+      uids.add(statement.id.name)
+    }
+  }
+  return uids
+}
+
+function tryAddUid(uid, program) {
+  let { _uids } = program
+  if (!_uids) {
+    _uids = program._uids = getUids(program)
+  }
+  if (_uids.has(uid)) return true
+  _uids.add(uid)
+}
+
+export function generateUid(name, program) {
+  name = toIdentifier(name)
+    .replace(/^_+/, '')
+    .replace(/[0-9]+$/g, '')
+
+  let uid
+  let i = 1
+  do {
+    uid = _generateUid(name, i++)
+  } while (tryAddUid(uid, program))
+
+  return uid
+}
+
+export function generateUidIdentifier(name, program) {
+  return identifier(generateUid(name, program))
+}