deno.com

class Module

Deno compatibility

The register method is a non-functional stub.

Constructors #

#Module(
id: string,
parent?: Module,
)
new

interface Module

extends [NodeJS.Module]

Deno compatibility

The register method is a non-functional stub.

Deno compatibility

The register method is a non-functional stub.

Properties #

#children: Module[]

The module objects required for the first time by this one.

#exports: any

The module.exports object is created by the Module system. Sometimes this is not acceptable; many want their module to be an instance of some class. To do this, assign the desired export object to module.exports.

#filename: string

The fully resolved filename of the module.

#id: string

The identifier for the module. Typically this is the fully resolved filename.

#isPreloading: boolean

true if the module is running during the Node.js preload phase.

#loaded: boolean

Whether or not the module is done loading, or is in the process of loading.

#parent:
Module
| null
| undefined
deprecated

The module that first required this one, or null if the current module is the entry point of the current process, or undefined if the module was loaded by something that is not a CommonJS module (e.g. REPL or import).

#path: string

The directory name of the module. This is usually the same as the path.dirname() of the module.id.

#paths: string[]

The search paths for the module.

Methods #

#require(id: string): any

The module.require() method provides a way to load a module as if require() was called from the original module.

namespace Module

Deno compatibility

The register method is a non-functional stub.

Classes #

Functions #

f
Module.createRequire
No documentation available
    f
    Module.enableCompileCache

    Enable module compile cache in the current Node.js instance.

      f
      Module.findPackageJSON
      No documentation available
        f
        Module.findSourceMap

        path is the resolved path for the file for which a corresponding source map should be fetched.

          f
          Module.flushCompileCache

          Flush the module compile cache accumulated from modules already loaded in the current Node.js instance to disk. This returns after all the flushing file system operations come to an end, no matter they succeed or not. If there are any errors, this will fail silently, since compile cache misses should not interfere with the actual operation of the application.

            f
            Module.getCompileCacheDir
            No documentation available
              f
              Module.isBuiltin
              No documentation available
                f
                Module.register

                Register a module that exports hooks that customize Node.js module resolution and loading behavior. See Customization hooks.

                  f
                  Module.runMain
                  No documentation available
                    f
                    Module.stripTypeScriptTypes

                    module.stripTypeScriptTypes() removes type annotations from TypeScript code. It can be used to strip type annotations from TypeScript code before running it with vm.runInContext() or vm.compileFunction(). By default, it will throw an error if the code contains TypeScript features that require transformation such as Enums, see type-stripping for more information. When mode is 'transform', it also transforms TypeScript features to JavaScript, see transform TypeScript features for more information. When mode is 'strip', source maps are not generated, because locations are preserved. If sourceMap is provided, when mode is 'strip', an error will be thrown.

                      f
                      Module.syncBuiltinESMExports

                      The module.syncBuiltinESMExports() method updates all the live bindings for builtin ES Modules to match the properties of the CommonJS exports. It does not add or remove exported names from the ES Modules.

                        f
                        Module.wrap
                        No documentation available

                          Interfaces #

                          I
                          Module.ImportAttributes
                          No documentation available

                          Namespaces #

                          N
                          Module.constants
                          No documentation available

                            Type Aliases #

                            T
                            Module.InitializeHook

                            The initialize hook provides a way to define a custom function that runs in the hooks thread when the hooks module is initialized. Initialization happens when the hooks module is registered via register.

                              T
                              Module.LoadHook

                              The load hook provides a way to define a custom method of determining how a URL should be interpreted, retrieved, and parsed. It is also in charge of validating the import attributes.

                                T
                                Module.ModuleFormat
                                No documentation available
                                  T
                                  Module.ModuleSource
                                  No documentation available
                                    T
                                    Module.ResolveHook

                                    The resolve hook chain is responsible for telling Node.js where to find and how to cache a given import statement or expression, or require call. It can optionally return a format (such as 'module') as a hint to the load hook. If a format is specified, the load hook is ultimately responsible for providing the final format value (and it is free to ignore the hint provided by resolve); if resolve provides a format, a custom load hook is required even if only to pass the value to the Node.js default load hook.

                                      Variables #

                                      v
                                      Module.builtinModules

                                      A list of the names of all modules provided by Node.js. Can be used to verify if a module is maintained by a third party or not.