Package org.mozilla.javascript.commonjs.module

Class Require

  • All Implemented Interfaces:
    java.io.Serializable, Callable, ConstProperties, DebuggableObject, Function, IdFunctionCall, Scriptable
    public class Require
extends BaseFunction
    Implements the require() function as defined by Common JS modules.

    Thread safety

    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.

    Creation

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

    Making it available

    In order to make the require() function available to your JavaScript program, you need to invoke either install(Scriptable) or requireMain(Context, String).
    See Also:
    Serialized Form

    • Constructor Detail

      • Require

        public Require​(Context cx,
               Scriptable 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(Scriptable), 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 Detail

      • requireMain

        public Scriptable requireMain​(Context cx,
                              java.lang.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:
        java.lang.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​(Scriptable 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 java.lang.Object call​(Context cx,
                             Scriptable scope,
                             Scriptable thisObj,
                             java.lang.Object[] args)
        Description copied from class: BaseFunction
        Should be overridden.
        Specified by:
        call in interface Callable
        Specified by:
        call in interface Function
        Overrides:
        call in class BaseFunction
        Parameters:
        cx - the current Context for this thread
        scope - the scope to execute the function relative to. This is set to the value returned by getParentScope() except when the function is called from a closure.
        thisObj - the JavaScript this object
        args - the array of arguments
        Returns:
        the result of the call

      • construct

        public Scriptable construct​(Context cx,
                            Scriptable scope,
                            java.lang.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.
        Specified by:
        construct in interface Function
        Overrides:
        construct in class BaseFunction
        Parameters:
        cx - the current Context for this thread
        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