ResourceLoader/Package files

A package module is a type of ResourceLoader module that can consist of multiple script files or data exports, accessible to the module's entry point via.

To enable this feature in a module, use the  property of a module descriptor. Traditional modules specify multiple script files with the  property, which blindly concatenates them as if they were a single script without ability to separately access them client-side.

Node.js compatibility
This feature was originally conceived as a way to make code written for Node.js easier to integrate with ResourceLoader. Libraries that contain multiple files that  each other, could be registered as a ResourceLoader module without modification.

Private export and import
The ability to export values from individual files and import them within a module, has also proved useful for modernising JS code in MediaWiki itself, by no longer needing to attach all classes to a public and global object.

Data and config bundling
The ability for a module to have multiple "files" that remain individually addressable, has also opened the door to support bundling of JSON files and virtual data exports from PHP (as JSON). The proposal to embed config variables in ResourceLoader modules, thus ended up being implemented as virtual files in a package module.

Before this feature existed, embedding config and data in modules was also possible, but required writing your own subclass of ResourceLoaderFileModule, an obscure technique that most developers didn't know about or felt uncomfortable using. Most instances of this technique in MediaWiki core have now been ported to use a virtual file in a package module instead.

A more common technique for exporting values from PHP was to export them with or through the   hook, as   keys. This is problematic for performance because:


 * Startup module config vars were exported on all page views for all users (wastes bandwidth cost), and need to be parsed and processed before your actual modules can begin to download (delays interaction), and were only cached for a short time (frequent re-download).
 * OutputPage config vars are in the  and block downloading of article text (delays visual rendering), and have to be processed before actual modules can start to begin downloading (delays interaction).

Exports part of a package module, on the other hand:


 * Only downloaded if they are needed, together with the code (saves bandwidth).
 * Only downloaded when they are needed (avoids rendering or interaction delays).


 * Benefit from longer caching times (only re-downloaded if they change, as part of the module).

How it works
A package file can either be JavaScript code (script), or a JSON blob (data). A file's type is inferred based on its extension ( or  ). Files can be real files or the file system, or dynamic files generated by code. Dynamic files are commonly used to export the values of configuration settings or other data from the server, and in those cases they're typically named  or.

Every module has one main file. This is the first file listed, unless another file is explicitly designated as the main file. When the module loads, only the code in the main file is executed. The code in the other files is not executed unless and until it is invoked using.

To invoke a non-main file, use. The path must start with  or   to indicate that it's a file in the same module (as opposed to the name of another module), and the path must be relative to the current file. The file suffix  is required. The return value of   is the value that foo.js assigns to.

Module definition
Files can be specified in the  property in the following ways:


 * will load a file from the filesystem
 * will load the file  from the file system, but its alias will be   (meaning it will be known under that name that for the purposes of  )
 * explicitly designates this file as the main file (the file that is executed first). If no main file is explicitly designated, the first file is the main file
 * defines a dynamic file called, with the specified contents
 * defines a dynamic file whose contents are
 * defines a dynamic file whose contents are the result of executing the callback
 * You can also specify a static function as a callback:  will call
 * For JS files, the callback should return a string. For JSON files, it can return anything that's JSON-serializable (typically an associative array)
 * The callback is executed in the context of a load.php request, so it doesn't know which user is logged in or which page is being viewed; instead, the result is computed once and reused across different users and pages. If you attempt to use the current user in your callback, you will likely get a  error. You should not use RequestContext in this callback. The ResourceLoaderContext object passed into the callback should have all the getters you need, including a   method to get a Config object, and a   method to format i18n messages.
 * defines a dynamic file whose contents are . Note that this syntax uses config setting names as understood by   (e.g.  ), not the names of global variables (e.g.  )
 * You can use aliases to export configuration variables under different names:  will result in
 * If you need to do more advanced manipulation of config variables, use a callback as described above. In the callback, you can use e.g.  to get the value of a config setting.

Base path
Most package modules set  to the common directory prefix of the files. This is done for convenience (not having to write  over and over), and to make dynamic files easier to deal with. Without a base path, a dynamic file called  would have to be accessed using , or it would have to be named   so it could be accessed using. With a base path, you get the best of both worlds.

Note that, if you set, you will also have to set   (for core) or   (for extensions) to match.

Incompatibility with
If a module uses the  property, it cannot use the   property. Defining a module that uses both properties will throw an exception.

Package modules are also incompatible with  and. Defining these properties won't throw an exception, but they will be ignored. A way of defining language/skin-specific script files for package modules has not yet been developed (and this blocks porting ResourceLoaderLanguageDataModule).

Example uses in real code

 * ProtectionForm: Move JS config var to RL packageFiles
 * Use packageFiles feature to replace special-purpose RL modules
 * RCFilters: Export config vars in the RL modules where possible (see also the revert and fix)
 * ScoreHooks: Bundle configuration vars into JS that needs it
 * WikibaseQualityConstraints: Use package module for constraint suggestions
 * [ your patches here! ]

Module definition (core)
In Resources.php:

Module definition (extension)
In extension.json: In MyExtensionHooks.php:

JavaScript
In init.js: In thinglib/index.js: In thinglib/formatter.js:

Debugging
In debug mode, traditional modules load each of their files in a separate request. This feature doesn't work with package modules. Each module is still loaded unminified an in a separate request from other modules, but all the files within the same module are bundled together in the same request. If you're having trouble finding a file or a piece of code using your browser's developer tools (for example, to place a breakpoint somewhere), you can use the following hack.

Suppose you're trying to find the file named  in the module named    from the example above, and want to place a breakpoint in it. You can do that as follows:


 * 1) In your browser console, run  . This will print something like   (in Chrome) or   (in Firefox).
 * 2) In Chrome, this will print something like  ; click on this text. In Firefox, this will print   followed by an arrow pointing up and to the right to three horizontal lines; click this icon.
 * 3) This will take you to the "Scripts" panel . If you see minified code, click the "pretty print" button (at the bottom left of the code pane, the icon looks like  ).
 * 4) In Chrome, you will now be looking at a line of code highlighted in yellow that looks like  . The code of   begins below this line. In Firefox, you won't be taken to this place automatically, you'll have to search for  to find it.

You can also access the exports of a file (i.e. the value it assigns to  and returned by  ) by running   in the console. Often this is a function or an object containing functions, which you can then access using steps 2-4 above.