or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

amd-loader.mdbuild-system.mdcommand-line.mdconfiguration.mdindex.mdplugins.md
tile.json

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.

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/requirejs@2.3.x

To install, run

npx @tessl/cli install tessl/npm-requirejs@2.3.0

index.mddocs/

RequireJS

RequireJS is a JavaScript file and module loader optimized for in-browser use, but it can be used in other JavaScript environments like Node.js, Rhino, and Nashorn. The r.js project contains both the RequireJS AMD loader and a powerful command-line optimizer for building and optimizing JavaScript modules and applications.

Package Information

  • Package Name: requirejs
  • Package Type: npm
  • Language: JavaScript
  • Installation: npm install requirejs

Core Imports

Browser usage with script tag:

<script src="require.js"></script>

Node.js usage:

const requirejs = require('requirejs');

CommonJS in Node.js:

const { requirejs, require, define } = require('requirejs');

Basic Usage

AMD Module Definition

// Define a module with dependencies
define('myModule', ['jquery', 'underscore'], function($, _) {
    return {
        doSomething: function() {
            console.log('Doing something with jQuery and Underscore');
        }
    };
});

// Define a simple module
define(function() {
    return {
        name: 'simple module',
        version: '1.0.0'
    };
});

Loading Modules

// Load modules and use them
require(['myModule'], function(myModule) {
    myModule.doSomething();
});

// Configure and load
requirejs.config({
    baseUrl: '/js',
    paths: {
        'jquery': 'lib/jquery-1.11.1.min'
    }
});

require(['jquery', 'myModule'], function($, myModule) {
    // Use jQuery and your module
});

Command Line Optimization

# Basic optimization
r.js -o build.js

# Quick single file build
r.js -o name=main out=main-built.js baseUrl=.

# Convert CommonJS to AMD
r.js -convert path/to/commonjs/dir path/to/amd/dir

Architecture

RequireJS consists of several key components:

  • AMD Loader: Core module loading system implementing the AMD specification
  • Configuration System: Flexible configuration API for paths, shims, and loader behavior
  • Build System: Sophisticated optimizer and bundling system for production deployment
  • Plugin System: Extensible plugin architecture for loading non-JavaScript resources
  • Multi-Environment: Support for browsers, Node.js, Rhino, Nashorn, and other JavaScript engines

Capabilities

AMD Module Loading

Core AMD (Asynchronous Module Definition) functionality for defining and loading JavaScript modules with dependency management.

// Main loader functions
function requirejs(deps, callback, errback, optional);
function require(deps, callback, errback, optional);
function define(name, deps, callback);

AMD Module Loading

Configuration

Comprehensive configuration system for customizing loader behavior, paths, and module resolution.

function requirejs.config(config);

interface RequireConfig {
    baseUrl?: string;
    paths?: { [key: string]: string };
    shim?: { [key: string]: ShimConfig };
    map?: { [key: string]: { [key: string]: string } };
    // ... and many more options
}

Configuration

Build System

Advanced build and optimization system for creating production-ready JavaScript bundles with minification and dependency analysis.

// Build configuration interface (simplified)
interface BuildConfig {
    appDir?: string;
    baseUrl?: string;
    dir?: string;
    modules?: ModuleConfig[];
    optimize?: 'uglify' | 'uglify2' | 'closure' | 'none';
    optimizeCss?: string;
    // ... 50+ build options
}

Build System

Command Line Interface

Command-line tools for optimization, conversion, and module management tasks.

# CLI Options
r.js [options] [script.js]
r.js -o build.js
r.js -v
r.js -convert sourceDir targetDir

Command Line Interface

Plugin System

Extensible plugin system for loading and processing non-JavaScript resources like text files, CSS, and custom content types.

// Plugin interface
interface RequirePlugin {
    load(name, require, onload, config);
    normalize?(name, normalize);
    write?(pluginName, moduleName, write, config);
}

Plugin System

Types

interface ShimConfig {
    deps?: string[];           // Dependencies for the shimmed script  
    exports?: string;          // Global variable name to export
    init?: Function;          // Initialization function
}

interface PackageConfig {
    name: string;             // Package name
    location?: string;        // Package location path
    main?: string;           // Main module file
}

interface ModuleConfig {
    name: string;                      // Module name/path
    include?: string[];               // Additional modules to include
    exclude?: string[];               // Modules to exclude
    excludeShallow?: string[];        // Exclude only direct dependencies
    create?: boolean;                 // Create module if it doesn't exist
    out?: string;                     // Specific output file
    override?: Partial<BuildConfig>;  // Override options for this module
}