CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/npm-requirejs

A command line tool for running JavaScript scripts that use the Asynchronous Module Definition API (AMD) for declaring and using JavaScript modules and regular JavaScript script files.

—

Pending
Overview
Eval results
Files

amd-loader.mddocs/

AMD Loader

The RequireJS AMD (Asynchronous Module Definition) loader provides the runtime module loading system for JavaScript applications. It implements the complete AMD specification, enabling modular JavaScript development with automatic dependency resolution and asynchronous loading.

Core Functions

requirejs()

Main module loading function that can be used for both configuration and module loading.

requirejs(deps, callback, errback, optional)

Parameters:

  • deps (Array|String|Object) - Dependencies array, single module name, or configuration object
  • callback (Function, optional) - Success callback function
  • errback (Function, optional) - Error callback function
  • optional (Object, optional) - Optional configuration parameters

Returns: Context require function or undefined

Usage Examples:

// Load modules with dependencies
requirejs(['jquery', 'backbone'], function($, Backbone) {
    // Use loaded modules
    console.log('jQuery version:', $.fn.jquery);
});

// Load single module
requirejs(['app/main'], function(main) {
    main.init();
});

// Configuration usage
requirejs({
    baseUrl: '/js',
    paths: {
        'jquery': 'vendor/jquery-3.6.0'
    }
});

require()

Alias for the main requirejs function, providing the same functionality.

require(deps, callback, errback, optional)

Parameters: Same as requirejs()

Usage Example:

require(['utils/helper', 'models/user'], function(helper, User) {
    const user = new User();
    helper.log('User created');
});

define()

Defines AMD modules with optional dependencies and exports.

define(name, deps, callback)

Parameters:

  • name (String, optional) - Module name/ID
  • deps (Array, optional) - Array of dependency module IDs
  • callback (Function|Object) - Module definition function or object

Returns: undefined

Usage Examples:

// Named module with dependencies
define('myModule', ['jquery', 'underscore'], function($, _) {
    return {
        init: function() {
            console.log('Module initialized');
        }
    };
});

// Anonymous module with dependencies
define(['dep1', 'dep2'], function(dep1, dep2) {
    return {
        // module exports
    };
});

// Simple object export
define({
    name: 'My Module',
    version: '1.0'
});

// Function export
define(function() {
    return function(msg) {
        console.log(msg);
    };
});

Configuration API

requirejs.config()

Configures the RequireJS loader with various options for module loading behavior.

requirejs.config(config)
require.config(config)

Parameters:

  • config (Object) - Configuration object

Configuration Options:

requirejs.config({
    // Base URL for module loading
    baseUrl: '/js',
    
    // Path mappings for module names
    paths: {
        'backbone': 'vendor/backbone-1.4.0',
        'underscore': 'vendor/underscore-1.13.1',
        'templates': '../templates'
    },
    
    // Shim configuration for non-AMD scripts
    shim: {
        'backbone': {
            deps: ['underscore', 'jquery'],
            exports: 'Backbone'
        },
        'underscore': {
            exports: '_'
        }
    },
    
    // Module ID mappings
    map: {
        '*': {
            'oldModule': 'newModule'
        },
        'some/newmodule': {
            'foo': 'foo1.2'
        }
    },
    
    // Package configurations
    packages: [
        {
            name: 'myPackage',
            location: 'vendor/myPackage',
            main: 'index'
        }
    ],
    
    // Module-specific configuration
    config: {
        'myModule': {
            apiKey: 'abc123',
            debug: true
        }
    },
    
    // Dependencies to load immediately
    deps: ['app/main'],
    
    // Callback after deps are loaded
    callback: function() {
        console.log('All dependencies loaded');
    },
    
    // Enforce define() usage
    enforceDefine: false,
    
    // Create script tags for XHTML
    xhtml: false,
    
    // Query string arguments for URLs
    urlArgs: 'v=' + Date.now(),
    
    // Script tag type attribute
    scriptType: 'text/javascript',
    
    // Skip data-main attribute processing
    skipDataMain: false
});

Properties and Utilities

requirejs.version

RequireJS version string.

console.log(requirejs.version); // "2.3.7"

requirejs.jsExtRegExp

Regular expression for detecting JavaScript file extensions.

const jsRegex = requirejs.jsExtRegExp;
console.log(jsRegex.test('module.js')); // true

requirejs.isBrowser

Boolean indicating if running in browser environment.

if (requirejs.isBrowser) {
    // Browser-specific code
}

requirejs.nextTick()

Execute function on next event loop tick.

requirejs.nextTick(fn)

Parameters:

  • fn (Function) - Function to execute

Usage:

requirejs.nextTick(function() {
    console.log('Executed on next tick');
});

requirejs.onError()

Default error handler for require errors. Can be overridden for custom error handling.

requirejs.onError = function(err) {
    console.error('RequireJS Error:', err.requireType);
    console.error('Modules:', err.requireModules);
    throw err;
};

Error Properties:

  • err.requireType - Error category
  • err.requireModules - Array of module IDs involved in error

requirejs.createNode()

Create script DOM element for module loading (browser environments).

requirejs.createNode(config, moduleName, url)

Parameters:

  • config (Object) - RequireJS configuration
  • moduleName (String) - Name of module being loaded
  • url (String) - URL of script to load

Returns: DOM script element

requirejs.load()

Load a module script.

requirejs.load(context, moduleName, url)

Parameters:

  • context (Object) - RequireJS context
  • moduleName (String) - Module name
  • url (String) - Script URL

requirejs.exec()

Execute JavaScript code (used by transpiling plugins).

requirejs.exec(text)

Parameters:

  • text (String) - JavaScript code to execute

Returns: Execution result

Usage:

requirejs.exec('console.log("Hello from executed code");');

requirejs.toUrl()

Convert a module name to a URL path for resource loading.

requirejs.toUrl(moduleNamePlusExt)

Parameters:

  • moduleNamePlusExt (String) - Module name with file extension

Returns: String - Full URL path to the resource

Usage:

// Get URL for a text file
const templateUrl = require.toUrl('templates/header.html');

// Get URL for a CSS file
const styleUrl = require.toUrl('styles/main.css');

// Used commonly in plugins
define({
    load: function(name, req, onload, config) {
        const url = req.toUrl(name + '.txt');
        // Load resource from url...
    }
});

requirejs.undef()

Undefine a module, removing it from the registry and allowing it to be reloaded.

requirejs.undef(moduleName)

Parameters:

  • moduleName (String) - Name of module to undefine

Usage:

// Undefine a module so it can be reloaded
requirejs.undef('app/config');

// Reload the module
require(['app/config'], function(config) {
    // Uses fresh copy of the module
});

Special Dependencies

RequireJS provides several special dependency strings for accessing module metadata and functionality:

require

Local require function for loading modules relative to the current module.

define(['require'], function(require) {
    // Dynamically load modules
    require(['./localModule'], function(localMod) {
        // Use locally loaded module
    });
});

exports

Object for exporting module values (CommonJS-style).

define(['exports'], function(exports) {
    exports.myFunction = function() {
        return 'Hello World';
    };
});

module

Module metadata object containing module information.

define(['module'], function(module) {
    console.log('Module ID:', module.id);
    console.log('Module URI:', module.uri);
    console.log('Module config:', module.config());
});

Context Management

Multiple Contexts

RequireJS supports multiple independent contexts for isolating module namespaces.

// Create custom context
const myContext = requirejs.config({
    context: 'myApp',
    baseUrl: '/js/myapp'
});

// Use context-specific require
myContext(['module1'], function(mod1) {
    // Module loaded in myApp context
});

Context Methods

// Get require function for context
const contextRequire = requirejs.config({
    context: 'myContext'
});

// Check if module is defined
contextRequire.defined('moduleName');

// Get module if defined
contextRequire.specified('moduleName');

AMD Feature Detection

define.amd

AMD feature detection property indicating AMD support.

if (typeof define === 'function' && define.amd) {
    // AMD environment detected
    define(['jquery'], function($) {
        // AMD module definition
    });
} else {
    // Non-AMD environment
}

The define.amd object contains:

define.amd = {
    jQuery: true  // Indicates jQuery compatibility
};

Error Handling

Error Types

RequireJS categorizes errors by type via the requireType property:

  • 'timeout' - Module failed to load within timeout
  • 'nodefine' - Script did not call define()
  • 'scripterror' - Script loading error
  • 'mismatch' - Module name mismatch

Custom Error Handling

require(['nonexistent'], 
    function() {
        // Success callback
    },
    function(err) {
        console.error('Failed to load:', err.requireModules);
        console.error('Error type:', err.requireType);
    }
);

Advanced Usage

Dynamic Module Loading

define(['require'], function(require) {
    function loadUserModule(userId) {
        const modulePath = 'users/' + userId;
        require([modulePath], function(userModule) {
            // Use dynamically loaded module
        });
    }
    
    return { loadUserModule };
});

Conditional Loading

define(['require'], function(require) {
    if (typeof window !== 'undefined') {
        // Browser environment
        require(['dom/utils'], function(domUtils) {
            // Use DOM utilities
        });
    } else {
        // Node.js environment
        require(['node/utils'], function(nodeUtils) {
            // Use Node utilities
        });
    }
});

Install with Tessl CLI

npx tessl i tessl/npm-requirejs

docs

amd-loader.md

build-system.md

command-line.md

configuration.md

index.md

plugins.md

tile.json