Module org.htmlunit.corejs
Package org.htmlunit.corejs.javascript.commonjs.module

Class Require

java.lang.Object
org.htmlunit.corejs.javascript.SlotMapOwner<Scriptable>
org.htmlunit.corejs.javascript.ScriptableObject
org.htmlunit.corejs.javascript.BaseFunction
org.htmlunit.corejs.javascript.commonjs.module.Require
All Implemented Interfaces:
Serializable, Callable, ConstProperties<Scriptable>, Constructable, DebuggableObject, Function, PropHolder<Scriptable>, Scriptable, SymbolScriptable
public class Require extends BaseFunction
Implements the require() function as defined by Common JS modules.

<h1>Thread safety</h1>

You will ordinarily create one instance of require() for every top-level scope. This ordinarily means one instance per program execution, except if you use shared top-level scopes and installing most objects into them. Module loading is thread safe, so using a single require() in a shared top-level scope is also safe.

<h1>Creation</h1>

If you need to create many otherwise identical require() functions for different scopes, you might want to use RequireBuilder for convenience.

<h1>Making it available</h1>

In order to make the require() function available to your JavaScript program, you need to invoke either install(VarScope) or requireMain(Context, String).

Version:
$Id: Require.java,v 1.4 2011/04/07 20:26:11 hannes%helma.at Exp $
Author:
Attila Szegedi
See Also:

  • Constructor Details

    • Require

      public Require(Context cx, TopLevel nativeScope, ModuleScriptProvider moduleScriptProvider, Script preExec, Script postExec, boolean sandboxed)
      Creates a new instance of the require() function. Upon constructing it, you will either want to install it in the global (or some other) scope using install(VarScope), or alternatively, you can load the program's main module using requireMain(Context, String) and then act on the main module's exports.
      Parameters:
      cx - the current context
      nativeScope - a scope that provides the standard native JavaScript objects.
      moduleScriptProvider - a provider for module scripts
      preExec - an optional script that is executed in every module's scope before its module script is run.
      postExec - an optional script that is executed in every module's scope after its module script is run.
      sandboxed - if set to true, the require function will be sandboxed. This means that it doesn't have the "paths" property, and also that the modules it loads don't export the "module.uri" property.

  • Method Details

    • requireMain

      public Scriptable requireMain(Context cx, String mainModuleId)
      Calling this method establishes a module as being the main module of the program to which this require() instance belongs. The module will be loaded as if require()'d and its "module" property will be set as the "main" property of this require() instance. You have to call this method before the module has been loaded (that is, the call to this method must be the first to require the module and thus trigger its loading). Note that the main module will execute in its own scope and not in the global scope. Since all other modules see the global scope, executing the main module in the global scope would open it for tampering by other modules.
      Parameters:
      cx - the current context
      mainModuleId - the ID of the main module
      Returns:
      the "exports" property of the main module
      Throws:
      IllegalStateException - if the main module is already loaded when required, or if this require() instance already has a different main module set.

    • install

      public void install(VarScope scope)
      Binds this instance of require() into the specified scope under the property name "require".
      Parameters:
      scope - the scope where the require() function is to be installed.

    • call

      public Object call(Context cx, Object nt, VarScope scope, Object thisObj, Object[] args)
      Overrides:
      call in class BaseFunction

    • construct

      public Scriptable construct(Context cx, Object nt, VarScope scope, Object[] args)
      Description copied from interface: Function
      Call the function as a constructor.

      This method is invoked by the runtime in order to satisfy a use of the JavaScript new operator. This method is expected to create a new object and return it.

      If nt is equal to this then this call is equivalent `new f(...arguments), but reflection and super constructor calls may pass in different values.

      Specified by:
      construct in interface Constructable
      Specified by:
      construct in interface Function
      Overrides:
      construct in class BaseFunction
      Parameters:
      cx - the current Context for this thread
      nt - the new.target for this call,
      scope - an enclosing scope of the caller except when the function is called from a closure.
      args - the array of arguments
      Returns:
      the allocated object

    • getFunctionName

      public String getFunctionName()
      Overrides:
      getFunctionName in class BaseFunction

    • getArity

      public int getArity()
      Overrides:
      getArity in class BaseFunction

    • getLength

      public int getLength()
      Overrides:
      getLength in class BaseFunction