├── .gitattributes
├── .github
    └── workflows
    │   ├── ci.yml
    │   └── rich-navigation.yml.off
├── .gitignore
├── .gitmodules
├── .lsifrc.json
├── .vscode
    ├── launch.json
    ├── settings.json
    └── tasks.json
├── License.txt
├── README.md
├── SECURITY.md
├── ThirdPartyNotices.txt
├── package-lock.json
├── package.json
├── src
    ├── core
    │   ├── configuration.ts
    │   ├── env.ts
    │   ├── loaderEvents.ts
    │   ├── main.ts
    │   ├── moduleManager.ts
    │   ├── scriptLoader.ts
    │   ├── tsconfig.json
    │   └── utils.ts
    ├── loader.d.ts
    └── loader.js
├── tests
    ├── loader.test.js
    ├── loader.test.ts
    ├── ms-specific
    │   └── tests
    │   │   ├── fallback_double_fallback
    │   │       ├── _reporter.js
    │   │       ├── _test.js
    │   │       └── doublefoo2.js
    │   │   ├── fallback_original_works
    │   │       ├── _reporter.js
    │   │       ├── _test.js
    │   │       ├── a.js
    │   │       └── alt.js
    │   │   └── fallback_single_fallback
    │   │       ├── _reporter.js
    │   │       ├── _test.js
    │   │       └── foofallback.js
    ├── node-specific
    │   ├── _control.js
    │   ├── _loader.js
    │   ├── exporting-function
    │   │   ├── _test.js
    │   │   └── a.js
    │   ├── has-dirname
    │   │   ├── _test.js
    │   │   └── a.js
    │   ├── simple
    │   │   ├── _test.js
    │   │   └── folder
    │   │   │   └── foo.js
    │   ├── throwing-amd
    │   │   ├── _test.js
    │   │   └── a.js
    │   ├── what-is-this
    │   │   ├── _test.js
    │   │   └── a.js
    │   └── z-cached-data-create
    │   │   ├── _test.js
    │   │   ├── a.js
    │   │   └── cache-dir
    │   │       └── .gitkeep
    ├── qunit
    │   ├── qunit.css
    │   ├── qunit.d.ts
    │   └── qunit.js
    ├── run-tests.htm
    └── run-tests.js
└── tsconfig.json


/.gitattributes:
--------------------------------------------------------------------------------
 1 | # Keep CRLF line terminators out of our text files,
 2 | # regardless of the "core.autocrlf" setting.
 3 | * text=auto
 4 | 
 5 | # We already ask TypeScript to use this form for its output files;
 6 | # ask git to do the same to avoid flip-flopping.
 7 | *.js eol=lf
 8 | *.ts.d eol=lf
 9 | *.map eol=lf
10 | 


--------------------------------------------------------------------------------
/.github/workflows/ci.yml:
--------------------------------------------------------------------------------
 1 | name: CI
 2 | 
 3 | on: [push, pull_request]
 4 | 
 5 | jobs:
 6 |   build:
 7 |     name: CI
 8 |     runs-on: ubuntu-latest
 9 |     steps:
10 |       - uses: actions/checkout@v2
11 |       - uses: actions/setup-node@v2
12 |         with:
13 |           node-version: 14
14 |       - run: npm ci
15 |       - run: npm run compile
16 |       - run: npm test
17 | 


--------------------------------------------------------------------------------
/.github/workflows/rich-navigation.yml.off:
--------------------------------------------------------------------------------
 1 | name: "Rich Navigation Indexing"
 2 | on:
 3 |   workflow_dispatch:
 4 |   pull_request:
 5 |   push:
 6 |     branches:
 7 |       - main
 8 | 
 9 | jobs:
10 |   richnav:
11 |     runs-on: windows-latest
12 |     steps:
13 |       - uses: actions/checkout@v2
14 | 
15 |       - uses: actions/setup-node@v2
16 |         with:
17 |           node-version: 14
18 | 
19 |       - name: Install dependencies
20 |         run: npm install
21 | 
22 |       - uses: microsoft/RichCodeNavIndexer@v0.1
23 |         with:
24 |           languages: typescript
25 |           repo-token: ${{ secrets.GITHUB_TOKEN }}
26 |           typescriptVersion: 0.6.0-next.21
27 |           configFiles: .lsifrc.json
28 |         continue-on-error: true
29 | 
30 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | .settings/user.json
2 | bin/
3 | obj/
4 | *.suo
5 | *.csproj.user
6 | *.js.map
7 | node_modules/
8 | *.lsif


--------------------------------------------------------------------------------
/.gitmodules:
--------------------------------------------------------------------------------
1 | [submodule "tests/amdjs-tests"]
2 | 	path = tests/amdjs-tests
3 | 	url = https://github.com/amdjs/amdjs-tests.git
4 | 


--------------------------------------------------------------------------------
/.lsifrc.json:
--------------------------------------------------------------------------------
1 | {
2 | 	"project": "./tsconfig.json",
3 | 	"out": "vscode-loader.lsif",
4 | 	"source": "./package.json",
5 | 	"package": "./package.json"
6 | }


--------------------------------------------------------------------------------
/.vscode/launch.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	// Use IntelliSense to learn about possible Node.js debug attributes.
 3 | 	// Hover to view descriptions of existing attributes.
 4 | 	// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
 5 | 	"version": "0.2.0",
 6 | 	"configurations": [
 7 | 		{
 8 | 			"type": "node",
 9 | 			"request": "launch",
10 | 			"name": "Launch Program",
11 | 			"program": "${workspaceRoot}/tests/run-tests.js"
12 | 		}
13 | 	]
14 | }


--------------------------------------------------------------------------------
/.vscode/settings.json:
--------------------------------------------------------------------------------
 1 | // Place your settings in this file to overwrite default and user settings.
 2 | {
 3 | 	"files.trimTrailingWhitespace": true,
 4 | 	"editor.tabSize": 4,
 5 | 	"editor.insertSpaces": false,
 6 | 	"editor.formatOnSave": true,
 7 | 	"files.exclude": {
 8 | 		".git": true,
 9 | 		"**/*.js": {
10 | 			"when": "**/core/$(basename).ts"
11 | 		}
12 | 	},
13 | 	"typescript.tsdk": "./node_modules/typescript/lib",
14 | 	"git.branchProtection": ["main", "release/*"],
15 | 	"git.branchProtectionPrompt": "alwaysCommitToNewBranch",
16 | 	"git.branchRandomName.enable": true
17 | }
18 | 


--------------------------------------------------------------------------------
/.vscode/tasks.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	// See https://go.microsoft.com/fwlink/?LinkId=733558 
 3 | 	// for the documentation about the tasks.json format
 4 | 	"version": "2.0.0",
 5 | 	"tasks": [
 6 | 		{
 7 | 			"type": "npm",
 8 | 			"script": "compile-all",
 9 | 			"problemMatcher": [
10 | 				"$tsc"
11 | 			]
12 | 		}
13 | 	]
14 | }


--------------------------------------------------------------------------------
/License.txt:
--------------------------------------------------------------------------------
 1 | 
 2 | Copyright (c) Microsoft Corporation
 3 | 
 4 | All rights reserved. 
 5 | 
 6 | MIT License
 7 | 
 8 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation 
 9 | files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy,
10 | modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software 
11 | is furnished to do so, subject to the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
16 | OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 
17 | BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT 
18 | OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
19 | 
20 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # VSCode Loader
  2 | 
  3 | An universal [Asynchronous Module Definition (AMD)](https://github.com/amdjs/amdjs-api/wiki/AMD) Loader developed primarily to load VSCode's sources.
  4 | 
  5 | ## Supported environments
  6 | * Edge, Firefox, Chrome, Safari
  7 | * nodejs
  8 | * electron (renderer & browser processes)
  9 | In nodejs and electron, when loading a module, if it cannot be found with the AMD rules, it delegates loading them to the native `require`.
 10 | 
 11 | ## Features
 12 | 
 13 | * Runs factory methods as soon as dependencies are resolved.
 14 | 
 15 | ## Using
 16 | 
 17 | * In a browser environment:
 18 | ```html
 19 | <script type="text/javascript" src="loader.js"></script>
 20 | <script>
 21 | 	require.config({
 22 | 		// ...
 23 | 	});
 24 | 	require(['an/amd/module'], function(value) {
 25 | 		// code is loaded here
 26 | 	});
 27 | </script>
 28 | ```
 29 | * In a node environment:
 30 | ```javascript
 31 | var loader = require('loader');
 32 | loader.config({
 33 | 	// ...
 34 | });
 35 | loader(['an/amd/module'], function(value) {
 36 | 	// code is loaded here
 37 | });
 38 | ```
 39 | * Supported config options:
 40 |  * `baseUrl` - The prefix that will be aplied to all modules when they are resolved to a location
 41 |  * `paths` - Redirect rules for modules. The redirect rules will affect the module ids themselves
 42 |  * `config` - Per-module configuration
 43 |  * `catchError` - Catch errors when invoking the module factories
 44 |  * `recordStats` - Record statistics
 45 |  * `urlArgs` - The suffix that will be aplied to all modules when they are resolved to a location
 46 |  * `onError` - Callback that will be called when errors are encountered
 47 |  * `ignoreDuplicateModules` - The loader will issue warnings when duplicate modules are encountered. This list will inhibit those warnings if duplicate modules are expected.
 48 |  * `isBuild` - Flag to indicate if current execution is as part of a build.
 49 |  * `cspNonce` - Allows setting a Content Security Policy nonce value on script tags created by the loader.
 50 |  * `nodeRequire` - The main entry point node's require
 51 |  * `nodeInstrumenter` - An optional transformation applied to the source before it is loaded in node's vm
 52 | 
 53 | ## Custom features
 54 | 
 55 | * Recording loading statistics for detailed script loading times:
 56 | ```javascript
 57 | require.config({
 58 | 	recordStats: true
 59 | });
 60 | // ...
 61 | console.log(require.getRecorder().getEvents());
 62 | ```
 63 | 
 64 | * Extracting loading metadata for a bundler:
 65 | ```javascript
 66 | var loader = require('loader');
 67 | loader.config({
 68 | 	isBuild: true
 69 | });
 70 | // ...
 71 | console.log(loader.getBuildInfo());
 72 | ```
 73 | 
 74 | ## Testing
 75 | 
 76 | To run the tests:
 77 | * code loading in node: `npm run test`
 78 | * amd spec tests, unit tests & code loading in browser:
 79 |   * `npm run simpleserver`
 80 |   * open `http://localhost:9999/tests/run-tests.htm`
 81 | 
 82 | The project uses as a submodule the [AMD compliance tests](https://github.com/amdjs/amdjs-tests). The goal is to support as many tests without adding `eval()` or an equivalent. It is also not a goal to support loading CommonJS code:
 83 | 
 84 | * Basic AMD Functionality (basic)
 85 | * The Basic require() Method (require)
 86 | * Anonymous Module Support (anon)
 87 | * ~~CommonJS Compatibility (funcString)~~
 88 | * ~~CommonJS Compatibility with Named Modules (namedWrap)~~
 89 | * AMD Loader Plugins (plugins)
 90 | * ~~Dynamic Plugins (pluginsDynamic)~~
 91 | * ~~Common Config: Packages~~
 92 | * ~~Common Config: Map~~
 93 | * ~~Common Config: Module~~
 94 | * Common Config: Path
 95 | * ~~Common Config: Shim~~
 96 | 
 97 | ## Developing
 98 | 
 99 | * Clone the repository
100 | * Run `git submodule init`
101 | * Run `git submodule update`
102 | * Run `npm install`
103 | * Compile in the background with `npm run watch1` and `npm run watch2`
104 | 
105 | ## Code of Conduct
106 | 
107 | This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.
108 | 
109 | ## License
110 | [MIT](https://github.com/microsoft/vscode-loader/blob/master/License.txt)
111 | 


--------------------------------------------------------------------------------
/SECURITY.md:
--------------------------------------------------------------------------------
 1 | <!-- BEGIN MICROSOFT SECURITY.MD V0.0.5 BLOCK -->
 2 | 
 3 | ## Security
 4 | 
 5 | Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include [Microsoft](https://github.com/Microsoft), [Azure](https://github.com/Azure), [DotNet](https://github.com/dotnet), [AspNet](https://github.com/aspnet), [Xamarin](https://github.com/xamarin), and [our GitHub organizations](https://opensource.microsoft.com/).
 6 | 
 7 | If you believe you have found a security vulnerability in any Microsoft-owned repository that meets [Microsoft's definition of a security vulnerability](https://docs.microsoft.com/en-us/previous-versions/tn-archive/cc751383(v=technet.10)), please report it to us as described below.
 8 | 
 9 | ## Reporting Security Issues
10 | 
11 | **Please do not report security vulnerabilities through public GitHub issues.**
12 | 
13 | Instead, please report them to the Microsoft Security Response Center (MSRC) at [https://msrc.microsoft.com/create-report](https://msrc.microsoft.com/create-report).
14 | 
15 | If you prefer to submit without logging in, send email to [secure@microsoft.com](mailto:secure@microsoft.com).  If possible, encrypt your message with our PGP key; please download it from the [Microsoft Security Response Center PGP Key page](https://www.microsoft.com/en-us/msrc/pgp-key-msrc).
16 | 
17 | You should receive a response within 24 hours. If for some reason you do not, please follow up via email to ensure we received your original message. Additional information can be found at [microsoft.com/msrc](https://www.microsoft.com/msrc).
18 | 
19 | Please include the requested information listed below (as much as you can provide) to help us better understand the nature and scope of the possible issue:
20 | 
21 |   * Type of issue (e.g. buffer overflow, SQL injection, cross-site scripting, etc.)
22 |   * Full paths of source file(s) related to the manifestation of the issue
23 |   * The location of the affected source code (tag/branch/commit or direct URL)
24 |   * Any special configuration required to reproduce the issue
25 |   * Step-by-step instructions to reproduce the issue
26 |   * Proof-of-concept or exploit code (if possible)
27 |   * Impact of the issue, including how an attacker might exploit the issue
28 | 
29 | This information will help us triage your report more quickly.
30 | 
31 | If you are reporting for a bug bounty, more complete reports can contribute to a higher bounty award. Please visit our [Microsoft Bug Bounty Program](https://microsoft.com/msrc/bounty) page for more details about our active programs.
32 | 
33 | ## Preferred Languages
34 | 
35 | We prefer all communications to be in English.
36 | 
37 | ## Policy
38 | 
39 | Microsoft follows the principle of [Coordinated Vulnerability Disclosure](https://www.microsoft.com/en-us/msrc/cvd).
40 | 
41 | <!-- END MICROSOFT SECURITY.MD BLOCK -->
42 | 


--------------------------------------------------------------------------------
/ThirdPartyNotices.txt:
--------------------------------------------------------------------------------
 1 | THIRD-PARTY SOFTWARE NOTICES AND INFORMATION
 2 | Do Not Translate or Localize
 3 | 
 4 | This project incorporates material from the project(s) listed below (collectively, "Third Party Code").
 5 | Microsoft is not the original author of the Third Party Code.  The original copyright notice and license
 6 | under which Microsoft received such Third Party Code are set out below. This Third Party Code is licensed
 7 | to you under their original license terms set forth below.  Microsoft reserves all other rights not
 8 | expressly granted, whether by implication, estoppel or otherwise.
 9 | 
10 | The following files/folders contain third party software used for development-time testing:
11 | 
12 | =========================================================================================================
13 | tests/qunit/**
14 | ---------------------------------------------------------------------------------------------------------
15 | The MIT License (MIT)
16 | 
17 | Copyright 2013 jQuery Foundation and other contributors
18 | 
19 | Permission is hereby granted, free of charge, to any person obtaining a copy
20 | of this software and associated documentation files (the "Software"), to deal
21 | in the Software without restriction, including without limitation the rights
22 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
23 | copies of the Software, and to permit persons to whom the Software is
24 | furnished to do so, subject to the following conditions:
25 | 
26 | The above copyright notice and this permission notice shall be included in
27 | all copies or substantial portions of the Software.
28 | 
29 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
30 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
31 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
32 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
33 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
34 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
35 | THE SOFTWARE.
36 | =========================================================================================================
37 | 


--------------------------------------------------------------------------------
/package-lock.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "@vscode/loader",
 3 |   "version": "1.0.0",
 4 |   "lockfileVersion": 2,
 5 |   "requires": true,
 6 |   "packages": {
 7 |     "": {
 8 |       "name": "@vscode/loader",
 9 |       "version": "1.0.0",
10 |       "license": "MIT",
11 |       "devDependencies": {
12 |         "typescript": "^4.9.5",
13 |         "yaserver": "^0.4.0"
14 |       }
15 |     },
16 |     "node_modules/typescript": {
17 |       "version": "4.9.5",
18 |       "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.5.tgz",
19 |       "integrity": "sha512-1FXk9E2Hm+QzZQ7z+McJiHL4NW1F2EzMu9Nq9i3zAaGqibafqYwCVU6WyWAuyQRRzOlxou8xZSyXLEN8oKj24g==",
20 |       "dev": true,
21 |       "bin": {
22 |         "tsc": "bin/tsc",
23 |         "tsserver": "bin/tsserver"
24 |       },
25 |       "engines": {
26 |         "node": ">=4.2.0"
27 |       }
28 |     },
29 |     "node_modules/yaserver": {
30 |       "version": "0.4.0",
31 |       "resolved": "https://registry.npmjs.org/yaserver/-/yaserver-0.4.0.tgz",
32 |       "integrity": "sha512-98Vj4sgqB1fLcpf2wK7h3dFCaabISHU9CXZHaAx3QLkvTTCD31MzMcNbw5V5jZFBK7ffkFqfWig6B20KQt4wtA==",
33 |       "dev": true,
34 |       "bin": {
35 |         "yaserver": "bin/yaserver"
36 |       }
37 |     }
38 |   },
39 |   "dependencies": {
40 |     "typescript": {
41 |       "version": "4.9.5",
42 |       "resolved": "https://registry.npmjs.org/typescript/-/typescript-4.9.5.tgz",
43 |       "integrity": "sha512-1FXk9E2Hm+QzZQ7z+McJiHL4NW1F2EzMu9Nq9i3zAaGqibafqYwCVU6WyWAuyQRRzOlxou8xZSyXLEN8oKj24g==",
44 |       "dev": true
45 |     },
46 |     "yaserver": {
47 |       "version": "0.4.0",
48 |       "resolved": "https://registry.npmjs.org/yaserver/-/yaserver-0.4.0.tgz",
49 |       "integrity": "sha512-98Vj4sgqB1fLcpf2wK7h3dFCaabISHU9CXZHaAx3QLkvTTCD31MzMcNbw5V5jZFBK7ffkFqfWig6B20KQt4wtA==",
50 |       "dev": true
51 |     }
52 |   }
53 | }
54 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "@vscode/loader",
 3 |   "version": "1.0.0",
 4 |   "description": "An universal AMD Loader",
 5 |   "main": "index.js",
 6 |   "directories": {
 7 |     "test": "tests"
 8 |   },
 9 |   "scripts": {
10 |     "watch1": "tsc -w -p src/core/tsconfig.json",
11 |     "watch2": "tsc -w -p tsconfig.json",
12 |     "compile": "tsc -p src/core/tsconfig.json && tsc -p tsconfig.json",
13 |     "test": "node ./tests/run-tests.js",
14 |     "simpleserver": "yaserver --root ./ --port 9999"
15 |   },
16 |   "repository": {
17 |     "type": "git",
18 |     "url": "git+https://github.com/microsoft/vscode-loader.git"
19 |   },
20 |   "author": "Microsoft Corporation",
21 |   "license": "MIT",
22 |   "bugs": {
23 |     "url": "https://github.com/microsoft/vscode-loader/issues"
24 |   },
25 |   "homepage": "https://github.com/microsoft/vscode-loader#readme",
26 |   "devDependencies": {
27 |     "typescript": "^4.9.5",
28 |     "yaserver": "^0.4.0"
29 |   }
30 | }
31 | 


--------------------------------------------------------------------------------
/src/core/configuration.ts:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------------------------
  2 |  *  Copyright (c) Microsoft Corporation. All rights reserved.
  3 |  *  Licensed under the MIT License. See License.txt in the project root for license information.
  4 |  *--------------------------------------------------------------------------------------------*/
  5 | 
  6 | namespace AMDLoader {
  7 | 
  8 | 	export interface AnnotatedLoadingError extends Error {
  9 | 		phase: 'loading';
 10 | 		moduleId: string;
 11 | 		neededBy: string[];
 12 | 	}
 13 | 
 14 | 	export interface AnnotatedFactoryError extends Error {
 15 | 		phase: 'factory';
 16 | 		moduleId: string;
 17 | 		neededBy: string[];
 18 | 	}
 19 | 
 20 | 	export interface AnnotatedValidationError extends Error {
 21 | 		phase: 'configuration';
 22 | 	}
 23 | 
 24 | 	export type AnnotatedError = AnnotatedLoadingError | AnnotatedFactoryError | AnnotatedValidationError;
 25 | 
 26 | 	export function ensureError<T extends Error>(err: any): T {
 27 | 		if (err instanceof Error) {
 28 | 			return <T>err;
 29 | 		}
 30 | 		const result = new Error(err.message || String(err) || 'Unknown Error');
 31 | 		if (err.stack) {
 32 | 			result.stack = err.stack;
 33 | 		}
 34 | 		return <T>result;
 35 | 	}
 36 | 
 37 | 	/**
 38 | 	 * The signature for the loader's AMD "define" function.
 39 | 	 */
 40 | 	export interface IDefineFunc {
 41 | 		(id: 'string', dependencies: string[], callback: any): void;
 42 | 		(id: 'string', callback: any): void;
 43 | 		(dependencies: string[], callback: any): void;
 44 | 		(callback: any): void;
 45 | 
 46 | 		amd: {
 47 | 			jQuery: boolean;
 48 | 		};
 49 | 	}
 50 | 
 51 | 	/**
 52 | 	 * The signature for the loader's AMD "require" function.
 53 | 	 */
 54 | 	export interface IRequireFunc {
 55 | 		(module: string): any;
 56 | 		(config: any): void;
 57 | 		(modules: string[], callback: Function): void;
 58 | 		(modules: string[], callback: Function, errorback: (err: any) => void): void;
 59 | 
 60 | 		config(params: IConfigurationOptions, shouldOverwrite?: boolean): void;
 61 | 
 62 | 		getConfig(): IConfigurationOptions;
 63 | 
 64 | 		/**
 65 | 		 * Non standard extension to reset completely the loader state. This is used for running amdjs tests
 66 | 		 */
 67 | 		reset(): void;
 68 | 
 69 | 		/**
 70 | 		 * Non standard extension to fetch loader state for building purposes.
 71 | 		 */
 72 | 		getBuildInfo(): IBuildModuleInfo[] | null;
 73 | 
 74 | 		/**
 75 | 		 * Non standard extension to fetch loader events
 76 | 		 */
 77 | 		getStats(): LoaderEvent[];
 78 | 
 79 | 		/**
 80 | 		 * The define function
 81 | 		 */
 82 | 		define(id: 'string', dependencies: string[], callback: any): void;
 83 | 		define(id: 'string', callback: any): void;
 84 | 		define(dependencies: string[], callback: any): void;
 85 | 		define(callback: any): void;
 86 | 
 87 | 		moduleManager?: ModuleManager;
 88 | 	}
 89 | 
 90 | 	export interface IModuleConfiguration {
 91 | 		[key: string]: any;
 92 | 	}
 93 | 
 94 | 	export interface INodeRequire {
 95 | 		(nodeModule: string): any;
 96 | 		main: {
 97 | 			filename: string;
 98 | 		};
 99 | 	}
100 | 
101 | 	export interface INodeCachedDataConfiguration {
102 | 		/**
103 | 		 * Directory path in which cached is stored.
104 | 		 */
105 | 		path: string;
106 | 		/**
107 | 		 * Seed when generating names of cache files.
108 | 		 */
109 | 		seed?: string;
110 | 		/**
111 | 		 * Optional delay for filesystem write/delete operations
112 | 		 */
113 | 		writeDelay?: number;
114 | 	};
115 | 
116 | 	export interface IConfigurationOptions {
117 | 		/**
118 | 		 * Allow module ids to end with .js
119 | 		 */
120 | 		allowJsExtension?: boolean;
121 | 		/**
122 | 		 * The prefix that will be aplied to all modules when they are resolved to a location
123 | 		 */
124 | 		baseUrl?: string;
125 | 		/**
126 | 		 * Redirect rules for modules. The redirect rules will affect the module ids themselves
127 | 		 */
128 | 		paths?: { [path: string]: any; };
129 | 		/**
130 | 		 * Per-module configuration
131 | 		 */
132 | 		config?: { [moduleId: string]: IModuleConfiguration };
133 | 		/**
134 | 		 * Catch errors when invoking the module factories
135 | 		 */
136 | 		catchError?: boolean;
137 | 		/**
138 | 		 * Record statistics
139 | 		 */
140 | 		recordStats?: boolean;
141 | 		/**
142 | 		 * The suffix that will be aplied to all modules when they are resolved to a location
143 | 		 */
144 | 		urlArgs?: string;
145 | 		/**
146 | 		 * Callback that will be called when errors are encountered
147 | 		 */
148 | 		onError?: (err: AnnotatedError) => void;
149 | 		/**
150 | 		 * The loader will issue warnings when duplicate modules are encountered.
151 | 		 * This list will inhibit those warnings if duplicate modules are expected.
152 | 		 */
153 | 		ignoreDuplicateModules?: string[];
154 | 		/**
155 | 		 * Flag to indicate if current execution is as part of a build. Used by plugins
156 | 		 */
157 | 		isBuild?: boolean;
158 | 		/**
159 | 		 * Normally, during a build, no module factories are invoked. This can be used
160 | 		 * to forcefully execute a module's factory.
161 | 		 */
162 | 		buildForceInvokeFactory?: { [moduleId: string]: boolean; }
163 | 		/**
164 | 		 * Content Security Policy nonce value used to load child scripts.
165 | 		 */
166 | 		cspNonce?: string;
167 | 		/**
168 | 		 * If running inside an electron renderer, prefer using <script> tags to load code.
169 | 		 * Defaults to false.
170 | 		 */
171 | 		preferScriptTags?: boolean;
172 | 		/**
173 | 		 * A trusted types policy which will be used to create TrustedScriptURL-values.
174 | 		 * https://w3c.github.io/webappsec-trusted-types/dist/spec/#introduction.
175 | 		 */
176 | 		trustedTypesPolicy?: {
177 | 			createScriptURL(value: string): string & object;
178 | 			createScript(_: string, value: string): string;
179 | 		};
180 | 		/**
181 | 		 * A regex to help determine if a module is an AMD module or a node module.
182 | 		 * If defined, then all amd modules in the system must match this regular expression.
183 | 		 */
184 | 		amdModulesPattern?: RegExp;
185 | 		/**
186 | 		 * The main entry point node's require
187 | 		 */
188 | 		nodeRequire?: INodeRequire;
189 | 		/**
190 | 		 * An optional transformation applied to the source before it is loaded in node's vm
191 | 		 */
192 | 		nodeInstrumenter?: (source: string, vmScriptSrc: string) => string;
193 | 		/**
194 | 		* Support v8 cached data (http://v8project.blogspot.co.uk/2015/07/code-caching.html)
195 | 		*/
196 | 		nodeCachedData?: INodeCachedDataConfiguration
197 | 	}
198 | 
199 | 	export interface IValidatedConfigurationOptions extends IConfigurationOptions {
200 | 		allowJsExtension: boolean;
201 | 		baseUrl: string;
202 | 		paths: { [path: string]: any; };
203 | 		config: { [moduleId: string]: IModuleConfiguration };
204 | 		catchError: boolean;
205 | 		recordStats: boolean;
206 | 		urlArgs: string;
207 | 		onError: (err: AnnotatedError) => void;
208 | 		ignoreDuplicateModules: string[];
209 | 		isBuild: boolean;
210 | 		cspNonce: string;
211 | 		preferScriptTags: boolean;
212 | 	}
213 | 
214 | 	export class ConfigurationOptionsUtil {
215 | 
216 | 		/**
217 | 		 * Ensure configuration options make sense
218 | 		 */
219 | 		private static validateConfigurationOptions(options: IConfigurationOptions): IValidatedConfigurationOptions {
220 | 
221 | 			function defaultOnError(err: AnnotatedError): void {
222 | 				if (err.phase === 'loading') {
223 | 					console.error('Loading "' + err.moduleId + '" failed');
224 | 					console.error(err);
225 | 					console.error('Here are the modules that depend on it:');
226 | 					console.error(err.neededBy);
227 | 					return;
228 | 				}
229 | 
230 | 				if (err.phase === 'factory') {
231 | 					console.error('The factory function of "' + err.moduleId + '" has thrown an exception');
232 | 					console.error(err);
233 | 					console.error('Here are the modules that depend on it:');
234 | 					console.error(err.neededBy);
235 | 					return;
236 | 				}
237 | 			}
238 | 
239 | 			options = options || {};
240 | 			if (typeof options.allowJsExtension !== 'boolean') {
241 | 				options.allowJsExtension = false;
242 | 			}
243 | 			if (typeof options.baseUrl !== 'string') {
244 | 				options.baseUrl = '';
245 | 			}
246 | 			if (typeof options.isBuild !== 'boolean') {
247 | 				options.isBuild = false;
248 | 			}
249 | 			if (typeof options.paths !== 'object') {
250 | 				options.paths = {};
251 | 			}
252 | 			if (typeof options.config !== 'object') {
253 | 				options.config = {};
254 | 			}
255 | 			if (typeof options.catchError === 'undefined') {
256 | 				options.catchError = false;
257 | 			}
258 | 			if (typeof options.recordStats === 'undefined') {
259 | 				options.recordStats = false;
260 | 			}
261 | 			if (typeof options.urlArgs !== 'string') {
262 | 				options.urlArgs = '';
263 | 			}
264 | 			if (typeof options.onError !== 'function') {
265 | 				options.onError = defaultOnError;
266 | 			}
267 | 			if (!Array.isArray(options.ignoreDuplicateModules)) {
268 | 				options.ignoreDuplicateModules = [];
269 | 			}
270 | 			if (options.baseUrl.length > 0) {
271 | 				if (!Utilities.endsWith(options.baseUrl, '/')) {
272 | 					options.baseUrl += '/';
273 | 				}
274 | 			}
275 | 			if (typeof options.cspNonce !== 'string') {
276 | 				options.cspNonce = '';
277 | 			}
278 | 			if (typeof options.preferScriptTags === 'undefined') {
279 | 				options.preferScriptTags = false;
280 | 			}
281 | 			if (options.nodeCachedData && typeof options.nodeCachedData === 'object') {
282 | 				if (typeof options.nodeCachedData.seed !== 'string') {
283 | 					options.nodeCachedData.seed = 'seed';
284 | 				}
285 | 				if (typeof options.nodeCachedData.writeDelay !== 'number' || options.nodeCachedData.writeDelay < 0) {
286 | 					options.nodeCachedData.writeDelay = 1000 * 7;
287 | 				}
288 | 				if (!options.nodeCachedData.path || typeof options.nodeCachedData.path !== 'string') {
289 | 					const err = ensureError<AnnotatedValidationError>(new Error('INVALID cached data configuration, \'path\' MUST be set'));
290 | 					err.phase = 'configuration';
291 | 					options.onError(err);
292 | 					options.nodeCachedData = undefined;
293 | 				}
294 | 			}
295 | 
296 | 			return <IValidatedConfigurationOptions>options;
297 | 		}
298 | 
299 | 		public static mergeConfigurationOptions(overwrite: IConfigurationOptions | null = null, base: IConfigurationOptions | null = null): IValidatedConfigurationOptions {
300 | 			let result: IConfigurationOptions = Utilities.recursiveClone(base || {});
301 | 
302 | 			// Merge known properties and overwrite the unknown ones
303 | 			Utilities.forEachProperty(overwrite, (key: string, value: any) => {
304 | 				if (key === 'ignoreDuplicateModules' && typeof result.ignoreDuplicateModules !== 'undefined') {
305 | 					result.ignoreDuplicateModules = result.ignoreDuplicateModules.concat(value);
306 | 				} else if (key === 'paths' && typeof result.paths !== 'undefined') {
307 | 					Utilities.forEachProperty(value, (key2: string, value2: any) => result.paths![key2] = value2);
308 | 				} else if (key === 'config' && typeof result.config !== 'undefined') {
309 | 					Utilities.forEachProperty(value, (key2: string, value2: any) => result.config![key2] = value2);
310 | 				} else {
311 | 					result[key] = Utilities.recursiveClone(value);
312 | 				}
313 | 			});
314 | 
315 | 			return ConfigurationOptionsUtil.validateConfigurationOptions(result);
316 | 		}
317 | 	}
318 | 
319 | 	export class Configuration {
320 | 
321 | 		private readonly _env: Environment;
322 | 
323 | 		private options: IValidatedConfigurationOptions;
324 | 
325 | 		/**
326 | 		 * Generated from the `ignoreDuplicateModules` configuration option.
327 | 		 */
328 | 		private ignoreDuplicateModulesMap: { [moduleId: string]: boolean; };
329 | 
330 | 		/**
331 | 		 * Generated from the `paths` configuration option. These are sorted with the longest `from` first.
332 | 		 */
333 | 		private sortedPathsRules: { from: string; to: string[]; }[];
334 | 
335 | 		constructor(env: Environment, options?: IConfigurationOptions) {
336 | 			this._env = env;
337 | 			this.options = ConfigurationOptionsUtil.mergeConfigurationOptions(options);
338 | 
339 | 			this._createIgnoreDuplicateModulesMap();
340 | 			this._createSortedPathsRules();
341 | 
342 | 			if (this.options.baseUrl === '') {
343 | 				if (this.options.nodeRequire && this.options.nodeRequire.main && this.options.nodeRequire.main.filename && this._env.isNode) {
344 | 					let nodeMain = this.options.nodeRequire.main.filename;
345 | 					let dirnameIndex = Math.max(nodeMain.lastIndexOf('/'), nodeMain.lastIndexOf('\\'));
346 | 					this.options.baseUrl = nodeMain.substring(0, dirnameIndex + 1);
347 | 				}
348 | 			}
349 | 		}
350 | 
351 | 		private _createIgnoreDuplicateModulesMap(): void {
352 | 			// Build a map out of the ignoreDuplicateModules array
353 | 			this.ignoreDuplicateModulesMap = {};
354 | 			for (let i = 0; i < this.options.ignoreDuplicateModules.length; i++) {
355 | 				this.ignoreDuplicateModulesMap[this.options.ignoreDuplicateModules[i]] = true;
356 | 			}
357 | 		}
358 | 
359 | 		private _createSortedPathsRules(): void {
360 | 			// Create an array our of the paths rules, sorted descending by length to
361 | 			// result in a more specific -> less specific order
362 | 			this.sortedPathsRules = [];
363 | 			Utilities.forEachProperty(this.options.paths, (from: string, to: any) => {
364 | 				if (!Array.isArray(to)) {
365 | 					this.sortedPathsRules.push({
366 | 						from: from,
367 | 						to: [to]
368 | 					});
369 | 				} else {
370 | 					this.sortedPathsRules.push({
371 | 						from: from,
372 | 						to: to
373 | 					});
374 | 				}
375 | 			});
376 | 			this.sortedPathsRules.sort((a, b) => {
377 | 				return b.from.length - a.from.length;
378 | 			});
379 | 		}
380 | 
381 | 		/**
382 | 		 * Clone current configuration and overwrite options selectively.
383 | 		 * @param options The selective options to overwrite with.
384 | 		 * @result A new configuration
385 | 		 */
386 | 		public cloneAndMerge(options?: IConfigurationOptions): Configuration {
387 | 			return new Configuration(this._env, ConfigurationOptionsUtil.mergeConfigurationOptions(options, this.options));
388 | 		}
389 | 
390 | 		/**
391 | 		 * Get current options bag. Useful for passing it forward to plugins.
392 | 		 */
393 | 		public getOptionsLiteral(): IValidatedConfigurationOptions {
394 | 			return this.options;
395 | 		}
396 | 
397 | 		private _applyPaths(moduleId: string): string[] {
398 | 			let pathRule: { from: string; to: string[]; };
399 | 			for (let i = 0, len = this.sortedPathsRules.length; i < len; i++) {
400 | 				pathRule = this.sortedPathsRules[i];
401 | 				if (Utilities.startsWith(moduleId, pathRule.from)) {
402 | 					let result: string[] = [];
403 | 					for (let j = 0, lenJ = pathRule.to.length; j < lenJ; j++) {
404 | 						result.push(pathRule.to[j] + moduleId.substr(pathRule.from.length));
405 | 					}
406 | 					return result;
407 | 				}
408 | 			}
409 | 			return [moduleId];
410 | 		}
411 | 
412 | 		private _addUrlArgsToUrl(url: string): string {
413 | 			if (Utilities.containsQueryString(url)) {
414 | 				return url + '&' + this.options.urlArgs;
415 | 			} else {
416 | 				return url + '?' + this.options.urlArgs;
417 | 			}
418 | 		}
419 | 
420 | 		private _addUrlArgsIfNecessaryToUrl(url: string): string {
421 | 			if (this.options.urlArgs) {
422 | 				return this._addUrlArgsToUrl(url);
423 | 			}
424 | 			return url;
425 | 		}
426 | 
427 | 		private _addUrlArgsIfNecessaryToUrls(urls: string[]): string[] {
428 | 			if (this.options.urlArgs) {
429 | 				for (let i = 0, len = urls.length; i < len; i++) {
430 | 					urls[i] = this._addUrlArgsToUrl(urls[i]);
431 | 				}
432 | 			}
433 | 			return urls;
434 | 		}
435 | 
436 | 		/**
437 | 		 * Transform a module id to a location. Appends .js to module ids
438 | 		 */
439 | 		public moduleIdToPaths(moduleIdOrPath: string): string[] {
440 | 
441 | 			if (this._env.isNode) {
442 | 				const isNodeModule = (
443 | 					this.options.amdModulesPattern instanceof RegExp
444 | 					&& !this.options.amdModulesPattern.test(moduleIdOrPath)
445 | 				);
446 | 
447 | 				if (isNodeModule) {
448 | 					// This is a node module...
449 | 					if (this.isBuild()) {
450 | 						// ...and we are at build time, drop it
451 | 						return ['empty:'];
452 | 					} else {
453 | 						// ...and at runtime we create a `shortcut`-path
454 | 						return ['node|' + moduleIdOrPath];
455 | 					}
456 | 				}
457 | 			}
458 | 
459 | 			const isAbsolutePath = Utilities.isAbsolutePath(moduleIdOrPath);
460 | 			const isJSFilePath = (this.options.allowJsExtension ? false : Utilities.endsWith(moduleIdOrPath, '.js'));
461 | 			const isModuleId = !(isAbsolutePath || isJSFilePath);
462 | 
463 | 			let result = moduleIdOrPath;
464 | 			let results: string[];
465 | 			if (isModuleId) {
466 | 				results = this._applyPaths(result);
467 | 
468 | 				for (let i = 0, len = results.length; i < len; i++) {
469 | 					if (this.isBuild() && results[i] === 'empty:') {
470 | 						continue;
471 | 					}
472 | 
473 | 					if (!Utilities.isAbsolutePath(results[i])) {
474 | 						results[i] = this.options.baseUrl + results[i];
475 | 					}
476 | 
477 | 					if (!Utilities.endsWith(results[i], '.js') && !Utilities.containsQueryString(results[i])) {
478 | 						results[i] = results[i] + '.js';
479 | 					}
480 | 				}
481 | 			} else {
482 | 				if (!Utilities.endsWith(result, '.js') && !Utilities.containsQueryString(result)) {
483 | 					result = result + '.js';
484 | 				}
485 | 				results = [result];
486 | 			}
487 | 
488 | 			return this._addUrlArgsIfNecessaryToUrls(results);
489 | 		}
490 | 
491 | 		/**
492 | 		 * Transform a module id or url to a location.
493 | 		 */
494 | 		public requireToUrl(url: string): string {
495 | 			let result = url;
496 | 
497 | 			if (!Utilities.isAbsolutePath(result)) {
498 | 				result = this._applyPaths(result)[0];
499 | 
500 | 				if (!Utilities.isAbsolutePath(result)) {
501 | 					result = this.options.baseUrl + result;
502 | 				}
503 | 			}
504 | 
505 | 			return this._addUrlArgsIfNecessaryToUrl(result);
506 | 		}
507 | 
508 | 		/**
509 | 		 * Flag to indicate if current execution is as part of a build.
510 | 		 */
511 | 		public isBuild(): boolean {
512 | 			return this.options.isBuild;
513 | 		}
514 | 
515 | 		public shouldInvokeFactory(strModuleId: string): boolean {
516 | 			if (!this.options.isBuild) {
517 | 				// outside of a build, all factories should be invoked
518 | 				return true;
519 | 			}
520 | 			// during a build, only explicitly marked or anonymous modules get their factories invoked
521 | 			if (Utilities.isAnonymousModule(strModuleId)) {
522 | 				return true;
523 | 			}
524 | 			if (this.options.buildForceInvokeFactory && this.options.buildForceInvokeFactory[strModuleId]) {
525 | 				return true;
526 | 			}
527 | 			return false;
528 | 		}
529 | 
530 | 		/**
531 | 		 * Test if module `moduleId` is expected to be defined multiple times
532 | 		 */
533 | 		public isDuplicateMessageIgnoredFor(moduleId: string): boolean {
534 | 			return this.ignoreDuplicateModulesMap.hasOwnProperty(moduleId);
535 | 		}
536 | 
537 | 		/**
538 | 		 * Get the configuration settings for the provided module id
539 | 		 */
540 | 		public getConfigForModule(moduleId: string): IModuleConfiguration | undefined {
541 | 			if (this.options.config) {
542 | 				return this.options.config[moduleId];
543 | 			}
544 | 		}
545 | 
546 | 		/**
547 | 		 * Should errors be caught when executing module factories?
548 | 		 */
549 | 		public shouldCatchError(): boolean {
550 | 			return this.options.catchError;
551 | 		}
552 | 
553 | 		/**
554 | 		 * Should statistics be recorded?
555 | 		 */
556 | 		public shouldRecordStats(): boolean {
557 | 			return this.options.recordStats;
558 | 		}
559 | 
560 | 		/**
561 | 		 * Forward an error to the error handler.
562 | 		 */
563 | 		public onError(err: AnnotatedError): void {
564 | 			this.options.onError(err);
565 | 		}
566 | 	}
567 | }
568 | 


--------------------------------------------------------------------------------
/src/core/env.ts:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------------------------
  2 |  *  Copyright (c) Microsoft Corporation. All rights reserved.
  3 |  *  Licensed under the MIT License. See License.txt in the project root for license information.
  4 |  *--------------------------------------------------------------------------------------------*/
  5 | 
  6 | /*---------------------------------------------------------------------------------------------
  7 |  *---------------------------------------------------------------------------------------------
  8 |  *---------------------------------------------------------------------------------------------
  9 |  *---------------------------------------------------------------------------------------------
 10 |  *---------------------------------------------------------------------------------------------
 11 |  * Please make sure to make edits in the .ts file at https://github.com/microsoft/vscode-loader/
 12 |  *---------------------------------------------------------------------------------------------
 13 |  *---------------------------------------------------------------------------------------------
 14 |  *---------------------------------------------------------------------------------------------
 15 |  *---------------------------------------------------------------------------------------------
 16 |  *--------------------------------------------------------------------------------------------*/
 17 | 
 18 | const _amdLoaderGlobal = this ?? globalThis;
 19 | 
 20 | declare var module: {
 21 | 	exports: any;
 22 | };
 23 | declare var process: {
 24 | 	platform: string;
 25 | 	type: string;
 26 | 	mainModule: string;
 27 | 	arch: string
 28 | 	argv: string[];
 29 | 	versions: {
 30 | 		node: string;
 31 | 		electron: string;
 32 | 	}
 33 | };
 34 | declare var require: {
 35 | 	nodeRequire(module: string): any;
 36 | };
 37 | declare var global: object;
 38 | const _commonjsGlobal = typeof global === 'object' ? global : {};
 39 | 
 40 | namespace AMDLoader {
 41 | 	export const global: any = _amdLoaderGlobal
 42 | 
 43 | 	export class Environment {
 44 | 
 45 | 		private _detected: boolean;
 46 | 		private _isWindows: boolean;
 47 | 		private _isNode: boolean;
 48 | 		private _isElectronRenderer: boolean;
 49 | 		private _isWebWorker: boolean;
 50 | 		private _isElectronNodeIntegrationWebWorker;
 51 | 
 52 | 		public get isWindows(): boolean {
 53 | 			this._detect();
 54 | 			return this._isWindows;
 55 | 		}
 56 | 		public get isNode(): boolean {
 57 | 			this._detect();
 58 | 			return this._isNode;
 59 | 		}
 60 | 		public get isElectronRenderer(): boolean {
 61 | 			this._detect();
 62 | 			return this._isElectronRenderer;
 63 | 		}
 64 | 		public get isWebWorker(): boolean {
 65 | 			this._detect();
 66 | 			return this._isWebWorker;
 67 | 		}
 68 | 		public get isElectronNodeIntegrationWebWorker(): boolean {
 69 | 			this._detect();
 70 | 			return this._isElectronNodeIntegrationWebWorker;
 71 | 		}
 72 | 
 73 | 		constructor() {
 74 | 			this._detected = false;
 75 | 			this._isWindows = false;
 76 | 			this._isNode = false;
 77 | 			this._isElectronRenderer = false;
 78 | 			this._isWebWorker = false;
 79 | 			this._isElectronNodeIntegrationWebWorker = false;
 80 | 		}
 81 | 
 82 | 		private _detect(): void {
 83 | 			if (this._detected) {
 84 | 				return;
 85 | 			}
 86 | 			this._detected = true;
 87 | 			this._isWindows = Environment._isWindows();
 88 | 			this._isNode = (typeof module !== 'undefined' && !!module.exports);
 89 | 			this._isElectronRenderer = (typeof process !== 'undefined' && typeof process.versions !== 'undefined' && typeof process.versions.electron !== 'undefined' && process.type === 'renderer');
 90 | 			this._isWebWorker = (typeof global.importScripts === 'function');
 91 | 			this._isElectronNodeIntegrationWebWorker = this._isWebWorker && (typeof process !== 'undefined' && typeof process.versions !== 'undefined' && typeof process.versions.electron !== 'undefined' && process.type === 'worker');
 92 | 		}
 93 | 
 94 | 		private static _isWindows(): boolean {
 95 | 			if (typeof navigator !== 'undefined') {
 96 | 				if (navigator.userAgent && navigator.userAgent.indexOf('Windows') >= 0) {
 97 | 					return true;
 98 | 				}
 99 | 			}
100 | 			if (typeof process !== 'undefined') {
101 | 				return (process.platform === 'win32');
102 | 			}
103 | 			return false;
104 | 		}
105 | 	}
106 | }
107 | 


--------------------------------------------------------------------------------
/src/core/loaderEvents.ts:
--------------------------------------------------------------------------------
 1 | /*---------------------------------------------------------------------------------------------
 2 |  *  Copyright (c) Microsoft Corporation. All rights reserved.
 3 |  *  Licensed under the MIT License. See License.txt in the project root for license information.
 4 |  *--------------------------------------------------------------------------------------------*/
 5 | 
 6 | namespace AMDLoader {
 7 | 
 8 | 	export const enum LoaderEventType {
 9 | 		LoaderAvailable = 1,
10 | 
11 | 		BeginLoadingScript = 10,
12 | 		EndLoadingScriptOK = 11,
13 | 		EndLoadingScriptError = 12,
14 | 
15 | 		BeginInvokeFactory = 21,
16 | 		EndInvokeFactory = 22,
17 | 
18 | 		NodeBeginEvaluatingScript = 31,
19 | 		NodeEndEvaluatingScript = 32,
20 | 
21 | 		NodeBeginNativeRequire = 33,
22 | 		NodeEndNativeRequire = 34,
23 | 
24 | 		CachedDataFound = 60,
25 | 		CachedDataMissed = 61,
26 | 		CachedDataRejected = 62,
27 | 		CachedDataCreated = 63,
28 | 	}
29 | 
30 | 	export class LoaderEvent {
31 | 		public type: LoaderEventType;
32 | 		public timestamp: number;
33 | 		public detail: string;
34 | 
35 | 		constructor(type: LoaderEventType, detail: string, timestamp: number) {
36 | 			this.type = type;
37 | 			this.detail = detail;
38 | 			this.timestamp = timestamp;
39 | 		}
40 | 	}
41 | 
42 | 	export interface ILoaderEventRecorder {
43 | 		record(type: LoaderEventType, detail: string): void;
44 | 		getEvents(): LoaderEvent[];
45 | 	}
46 | 
47 | 	export class LoaderEventRecorder implements ILoaderEventRecorder {
48 | 		private _events: LoaderEvent[];
49 | 
50 | 		constructor(loaderAvailableTimestamp: number) {
51 | 			this._events = [new LoaderEvent(LoaderEventType.LoaderAvailable, '', loaderAvailableTimestamp)];
52 | 		}
53 | 
54 | 		public record(type: LoaderEventType, detail: string): void {
55 | 			this._events.push(new LoaderEvent(type, detail, Utilities.getHighPerformanceTimestamp()));
56 | 		}
57 | 
58 | 		public getEvents(): LoaderEvent[] {
59 | 			return this._events;
60 | 		}
61 | 	}
62 | 
63 | 	export class NullLoaderEventRecorder implements ILoaderEventRecorder {
64 | 		public static INSTANCE = new NullLoaderEventRecorder();
65 | 
66 | 		public record(type: LoaderEventType, detail: string): void {
67 | 			// Nothing to do
68 | 		}
69 | 
70 | 		public getEvents(): LoaderEvent[] {
71 | 			return [];
72 | 		}
73 | 	}
74 | 
75 | }
76 | 


--------------------------------------------------------------------------------
/src/core/main.ts:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------------------------
  2 |  *  Copyright (c) Microsoft Corporation. All rights reserved.
  3 |  *  Licensed under the MIT License. See License.txt in the project root for license information.
  4 |  *--------------------------------------------------------------------------------------------*/
  5 | 
  6 | 'use strict';
  7 | 
  8 | // Limitation: To load jquery through the loader, always require 'jquery' and add a path for it in the loader configuration
  9 | 
 10 | declare var doNotInitLoader;
 11 | var define;
 12 | 
 13 | namespace AMDLoader {
 14 | 
 15 | 	const env = new Environment();
 16 | 
 17 | 	let moduleManager: ModuleManager = null!;
 18 | 
 19 | 	const DefineFunc: IDefineFunc = <any>function (id: any, dependencies: any, callback: any): void {
 20 | 		if (typeof id !== 'string') {
 21 | 			callback = dependencies;
 22 | 			dependencies = id;
 23 | 			id = null;
 24 | 		}
 25 | 		if (typeof dependencies !== 'object' || !Array.isArray(dependencies)) {
 26 | 			callback = dependencies;
 27 | 			dependencies = null;
 28 | 		}
 29 | 		if (!dependencies) {
 30 | 			dependencies = ['require', 'exports', 'module'];
 31 | 		}
 32 | 
 33 | 		if (id) {
 34 | 			moduleManager.defineModule(id, dependencies, callback, null, null);
 35 | 		} else {
 36 | 			moduleManager.enqueueDefineAnonymousModule(dependencies, callback);
 37 | 		}
 38 | 	};
 39 | 	DefineFunc.amd = {
 40 | 		jQuery: true
 41 | 	};
 42 | 
 43 | 	const _requireFunc_config = function (params: IConfigurationOptions, shouldOverwrite: boolean = false): void {
 44 | 		moduleManager.configure(params, shouldOverwrite);
 45 | 	};
 46 | 	const RequireFunc: IRequireFunc = <any>function () {
 47 | 		if (arguments.length === 1) {
 48 | 			if ((arguments[0] instanceof Object) && !Array.isArray(arguments[0])) {
 49 | 				_requireFunc_config(arguments[0]);
 50 | 				return;
 51 | 			}
 52 | 			if (typeof arguments[0] === 'string') {
 53 | 				return moduleManager.synchronousRequire(arguments[0]);
 54 | 			}
 55 | 		}
 56 | 		if (arguments.length === 2 || arguments.length === 3) {
 57 | 			if (Array.isArray(arguments[0])) {
 58 | 				moduleManager.defineModule(Utilities.generateAnonymousModule(), arguments[0], arguments[1], arguments[2], null);
 59 | 				return;
 60 | 			}
 61 | 		}
 62 | 		throw new Error('Unrecognized require call');
 63 | 	};
 64 | 	RequireFunc.config = _requireFunc_config;
 65 | 	RequireFunc.getConfig = function (): IConfigurationOptions {
 66 | 		return moduleManager.getConfig().getOptionsLiteral();
 67 | 	};
 68 | 	RequireFunc.reset = function (): void {
 69 | 		moduleManager = moduleManager.reset();
 70 | 	};
 71 | 	RequireFunc.getBuildInfo = function (): IBuildModuleInfo[] | null {
 72 | 		return moduleManager.getBuildInfo();
 73 | 	};
 74 | 	RequireFunc.getStats = function (): LoaderEvent[] {
 75 | 		return moduleManager.getLoaderEvents();
 76 | 	};
 77 | 	RequireFunc.define = DefineFunc;
 78 | 
 79 | 	export function init(): void {
 80 | 		if (typeof global.require !== 'undefined' || typeof require !== 'undefined') {
 81 | 			const _nodeRequire = (global.require || require);
 82 | 			if (typeof _nodeRequire === 'function' && typeof _nodeRequire.resolve === 'function') {
 83 | 				// re-expose node's require function
 84 | 				const nodeRequire = ensureRecordedNodeRequire(moduleManager.getRecorder(), _nodeRequire);
 85 | 				global.nodeRequire = nodeRequire;
 86 | 				(<any>RequireFunc).nodeRequire = nodeRequire;
 87 | 				(<any>RequireFunc).__$__nodeRequire = nodeRequire;
 88 | 			}
 89 | 		}
 90 | 
 91 | 		if (env.isNode && !env.isElectronRenderer && !env.isElectronNodeIntegrationWebWorker) {
 92 | 			module.exports = RequireFunc;
 93 | 		} else {
 94 | 			if (!env.isElectronRenderer) {
 95 | 				global.define = DefineFunc;
 96 | 			}
 97 | 			global.require = RequireFunc;
 98 | 		}
 99 | 	}
100 | 
101 | 	if (typeof global.define !== 'function' || !global.define.amd) {
102 | 		moduleManager = new ModuleManager(env, createScriptLoader(env), DefineFunc, RequireFunc, Utilities.getHighPerformanceTimestamp());
103 | 
104 | 		// The global variable require can configure the loader
105 | 		if (typeof global.require !== 'undefined' && typeof global.require !== 'function') {
106 | 			RequireFunc.config(global.require);
107 | 		}
108 | 
109 | 		// This define is for the local closure defined in node in the case that the loader is concatenated
110 | 		define = function () {
111 | 			return DefineFunc.apply(null, arguments);
112 | 		};
113 | 		define.amd = DefineFunc.amd;
114 | 
115 | 		if (typeof doNotInitLoader === 'undefined') {
116 | 			init();
117 | 		}
118 | 	}
119 | 
120 | }
121 | 


--------------------------------------------------------------------------------
/src/core/scriptLoader.ts:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------------------------
  2 |  *  Copyright (c) Microsoft Corporation. All rights reserved.
  3 |  *  Licensed under the MIT License. See License.txt in the project root for license information.
  4 |  *--------------------------------------------------------------------------------------------*/
  5 | 
  6 | namespace AMDLoader {
  7 | 
  8 | 	export interface IModuleManager {
  9 | 		getGlobalAMDDefineFunc(): IDefineFunc;
 10 | 		getGlobalAMDRequireFunc(): IRequireFunc;
 11 | 		getConfig(): Configuration;
 12 | 		enqueueDefineAnonymousModule(dependencies: string[], callback: any): void;
 13 | 		getRecorder(): ILoaderEventRecorder;
 14 | 	}
 15 | 
 16 | 	export interface IScriptLoader {
 17 | 		load(moduleManager: IModuleManager, scriptPath: string, loadCallback: () => void, errorCallback: (err: any) => void): void;
 18 | 	}
 19 | 
 20 | 	// ------------------------------------------------------------------------
 21 | 	// IScriptLoader(s)
 22 | 
 23 | 	// class LazyScriptLoader implements IScriptLoader {
 24 | 	// 	constructor() {
 25 | 
 26 | 	// 	}
 27 | 
 28 | 	// 	public load(moduleManager: IModuleManager, scriptPath: string, loadCallback: () => void, errorCallback: (err: any) => void): void {
 29 | 
 30 | 	// 	}
 31 | 	// }
 32 | 
 33 | 	interface IScriptCallbacks {
 34 | 		callback: () => void;
 35 | 		errorback: (err: any) => void;
 36 | 	}
 37 | 
 38 | 	/**
 39 | 	 * Load `scriptSrc` only once (avoid multiple <script> tags)
 40 | 	 */
 41 | 	class OnlyOnceScriptLoader implements IScriptLoader {
 42 | 
 43 | 		private readonly _env: Environment;
 44 | 		private _scriptLoader: IScriptLoader | null;
 45 | 		private readonly _callbackMap: { [scriptSrc: string]: IScriptCallbacks[]; };
 46 | 
 47 | 		constructor(env: Environment) {
 48 | 			this._env = env;
 49 | 			this._scriptLoader = null;
 50 | 			this._callbackMap = {};
 51 | 		}
 52 | 
 53 | 		public load(moduleManager: IModuleManager, scriptSrc: string, callback: () => void, errorback: (err: any) => void): void {
 54 | 			if (!this._scriptLoader) {
 55 | 				if (this._env.isWebWorker) {
 56 | 					this._scriptLoader = new WorkerScriptLoader();
 57 | 				} else if (this._env.isElectronRenderer) {
 58 | 					const { preferScriptTags } = moduleManager.getConfig().getOptionsLiteral();
 59 | 					if (preferScriptTags) {
 60 | 						this._scriptLoader = new BrowserScriptLoader();
 61 | 					} else {
 62 | 						this._scriptLoader = new NodeScriptLoader(this._env);
 63 | 					}
 64 | 				} else if (this._env.isNode) {
 65 | 					this._scriptLoader = new NodeScriptLoader(this._env);
 66 | 				} else {
 67 | 					this._scriptLoader = new BrowserScriptLoader();
 68 | 				}
 69 | 			}
 70 | 			let scriptCallbacks: IScriptCallbacks = {
 71 | 				callback: callback,
 72 | 				errorback: errorback
 73 | 			};
 74 | 			if (this._callbackMap.hasOwnProperty(scriptSrc)) {
 75 | 				this._callbackMap[scriptSrc].push(scriptCallbacks);
 76 | 				return;
 77 | 			}
 78 | 			this._callbackMap[scriptSrc] = [scriptCallbacks];
 79 | 			this._scriptLoader.load(moduleManager, scriptSrc, () => this.triggerCallback(scriptSrc), (err: any) => this.triggerErrorback(scriptSrc, err));
 80 | 		}
 81 | 
 82 | 		private triggerCallback(scriptSrc: string): void {
 83 | 			let scriptCallbacks = this._callbackMap[scriptSrc];
 84 | 			delete this._callbackMap[scriptSrc];
 85 | 
 86 | 			for (let i = 0; i < scriptCallbacks.length; i++) {
 87 | 				scriptCallbacks[i].callback();
 88 | 			}
 89 | 		}
 90 | 
 91 | 		private triggerErrorback(scriptSrc: string, err: any): void {
 92 | 			let scriptCallbacks = this._callbackMap[scriptSrc];
 93 | 			delete this._callbackMap[scriptSrc];
 94 | 
 95 | 			for (let i = 0; i < scriptCallbacks.length; i++) {
 96 | 				scriptCallbacks[i].errorback(err);
 97 | 			}
 98 | 		}
 99 | 	}
100 | 
101 | 	class BrowserScriptLoader implements IScriptLoader {
102 | 
103 | 		/**
104 | 		 * Attach load / error listeners to a script element and remove them when either one has fired.
105 | 		 * Implemented for browsers supporting HTML5 standard 'load' and 'error' events.
106 | 		 */
107 | 		private attachListeners(script: HTMLScriptElement, callback: () => void, errorback: (err: any) => void): void {
108 | 			let unbind = () => {
109 | 				script.removeEventListener('load', loadEventListener);
110 | 				script.removeEventListener('error', errorEventListener);
111 | 			};
112 | 
113 | 			let loadEventListener = (e: any) => {
114 | 				unbind();
115 | 				callback();
116 | 			};
117 | 
118 | 			let errorEventListener = (e: any) => {
119 | 				unbind();
120 | 				errorback(e);
121 | 			};
122 | 
123 | 			script.addEventListener('load', loadEventListener);
124 | 			script.addEventListener('error', errorEventListener);
125 | 		}
126 | 
127 | 		public load(moduleManager: IModuleManager, scriptSrc: string, callback: () => void, errorback: (err: any) => void): void {
128 | 			if (/^node\|/.test(scriptSrc)) {
129 | 				let opts = moduleManager.getConfig().getOptionsLiteral();
130 | 				let nodeRequire = ensureRecordedNodeRequire(moduleManager.getRecorder(), (opts.nodeRequire || AMDLoader.global.nodeRequire));
131 | 				let pieces = scriptSrc.split('|');
132 | 
133 | 				let moduleExports = null;
134 | 				try {
135 | 					moduleExports = nodeRequire(pieces[1]);
136 | 				} catch (err) {
137 | 					errorback(err);
138 | 					return;
139 | 				}
140 | 
141 | 				moduleManager.enqueueDefineAnonymousModule([], () => moduleExports);
142 | 				callback();
143 | 			} else {
144 | 				let script = document.createElement('script');
145 | 				script.setAttribute('async', 'async');
146 | 				script.setAttribute('type', 'text/javascript');
147 | 
148 | 				this.attachListeners(script, callback, errorback);
149 | 
150 | 				const { trustedTypesPolicy } = moduleManager.getConfig().getOptionsLiteral();
151 | 				if (trustedTypesPolicy) {
152 | 					scriptSrc = trustedTypesPolicy.createScriptURL(scriptSrc);
153 | 				}
154 | 				script.setAttribute('src', scriptSrc);
155 | 
156 | 				// Propagate CSP nonce to dynamically created script tag.
157 | 				const { cspNonce } = moduleManager.getConfig().getOptionsLiteral();
158 | 				if (cspNonce) {
159 | 					script.setAttribute('nonce', cspNonce);
160 | 				}
161 | 
162 | 				document.getElementsByTagName('head')[0].appendChild(script);
163 | 			}
164 | 		}
165 | 	}
166 | 
167 | 	function canUseEval(moduleManager: IModuleManager): boolean {
168 | 		const { trustedTypesPolicy } = moduleManager.getConfig().getOptionsLiteral();
169 | 		try {
170 | 			const func = (
171 | 				trustedTypesPolicy
172 | 					? self.eval(trustedTypesPolicy.createScript('', 'true'))
173 | 					: new Function('true') // CodeQL [SM01632] the loader is responsible with loading code, fetch + eval is used on the web worker instead of importScripts if possible because importScripts is synchronous and we observed deadlocks on Safari
174 | 			);
175 | 			func.call(self);
176 | 			return true;
177 | 		} catch (err) {
178 | 			return false;
179 | 		}
180 | 	}
181 | 
182 | 	class WorkerScriptLoader implements IScriptLoader {
183 | 
184 | 		private _cachedCanUseEval: boolean | null = null;
185 | 
186 | 		private _canUseEval(moduleManager: IModuleManager): boolean {
187 | 			if (this._cachedCanUseEval === null) {
188 | 				this._cachedCanUseEval = canUseEval(moduleManager);
189 | 			}
190 | 			return this._cachedCanUseEval;
191 | 		}
192 | 
193 | 		public load(moduleManager: IModuleManager, scriptSrc: string, callback: () => void, errorback: (err: any) => void): void {
194 | 
195 | 			if (/^node\|/.test(scriptSrc)) {
196 | 
197 | 				const opts = moduleManager.getConfig().getOptionsLiteral();
198 | 				const nodeRequire = ensureRecordedNodeRequire(moduleManager.getRecorder(), (opts.nodeRequire || AMDLoader.global.nodeRequire));
199 | 				const pieces = scriptSrc.split('|');
200 | 				let moduleExports = null;
201 | 				try {
202 | 					moduleExports = nodeRequire(pieces[1]);
203 | 				}
204 | 				catch (err) {
205 | 					errorback(err);
206 | 					return;
207 | 				}
208 | 				moduleManager.enqueueDefineAnonymousModule([], function () { return moduleExports; });
209 | 				callback();
210 | 
211 | 			} else {
212 | 
213 | 				const { trustedTypesPolicy } = moduleManager.getConfig().getOptionsLiteral();
214 | 
215 | 				const isCrossOrigin = (/^((http:)|(https:)|(file:))/.test(scriptSrc) && scriptSrc.substring(0, self.origin.length) !== self.origin);
216 | 				if (!isCrossOrigin && this._canUseEval(moduleManager)) {
217 | 					// use `fetch` if possible because `importScripts`
218 | 					// is synchronous and can lead to deadlocks on Safari
219 | 					fetch(scriptSrc).then((response) => {
220 | 						if (response.status !== 200) {
221 | 							throw new Error(response.statusText);
222 | 						}
223 | 						return response.text();
224 | 					}).then((text) => {
225 | 						text = `${text}\n//# sourceURL=${scriptSrc}`;
226 | 						const func = (
227 | 							trustedTypesPolicy
228 | 								? self.eval(trustedTypesPolicy.createScript('', text))
229 | 								: new Function(text) // CodeQL [SM01632] the loader is responsible with loading code, fetch + eval is used on the web worker instead of importScripts if possible because importScripts is synchronous and we observed deadlocks on Safari
230 | 						);
231 | 						func.call(self);
232 | 						callback();
233 | 					}).then(undefined, errorback);
234 | 					return;
235 | 				}
236 | 
237 | 				try {
238 | 					if (trustedTypesPolicy) {
239 | 						scriptSrc = trustedTypesPolicy.createScriptURL(scriptSrc);
240 | 					}
241 | 					importScripts(scriptSrc);
242 | 					callback();
243 | 				}
244 | 				catch (e) {
245 | 					errorback(e);
246 | 				}
247 | 			}
248 | 		}
249 | 	}
250 | 
251 | 	declare class Buffer {
252 | 		static from(value: string, encoding?: string): Buffer;
253 | 		static allocUnsafe(size: number): Buffer;
254 | 		static concat(buffers: Buffer[], totalLength?: number): Buffer;
255 | 		length: number;
256 | 		writeInt32BE(value: number, offset: number);
257 | 		readInt32BE(offset: number);
258 | 		slice(start?: number, end?: number): Buffer;
259 | 		equals(b: Buffer): boolean;
260 | 		toString(): string;
261 | 	}
262 | 
263 | 	interface INodeFS {
264 | 		readFile(filename: string, options: { encoding?: string; flag?: string }, callback: (err: any, data: any) => void): void;
265 | 		readFile(filename: string, callback: (err: any, data: Buffer) => void): void;
266 | 		readFileSync(filename: string): Buffer;
267 | 		writeFile(filename: string, data: Buffer, callback: (err: any) => void): void;
268 | 		unlink(path: string, callback: (err: any) => void): void;
269 | 	}
270 | 
271 | 	interface INodeVMScriptOptions {
272 | 		filename: string;
273 | 		cachedData?: Buffer;
274 | 	}
275 | 
276 | 	interface INodeVMScript {
277 | 		cachedData: Buffer;
278 | 		cachedDataProduced: boolean;
279 | 		cachedDataRejected: boolean;
280 | 		runInThisContext(options: INodeVMScriptOptions);
281 | 		createCachedData(): Buffer;
282 | 	}
283 | 
284 | 	interface INodeVM {
285 | 		Script: { new(contents: string, options?: INodeVMScriptOptions): INodeVMScript }
286 | 	}
287 | 
288 | 	interface INodePath {
289 | 		dirname(filename: string): string;
290 | 		normalize(filename: string): string;
291 | 		basename(filename: string): string;
292 | 		join(...parts: string[]): string;
293 | 	}
294 | 
295 | 	interface INodeCryptoHash {
296 | 		update(str: string, encoding: string): INodeCryptoHash;
297 | 		digest(type: string): string;
298 | 		digest(): Buffer;
299 | 	}
300 | 	interface INodeCrypto {
301 | 		createHash(type: string): INodeCryptoHash;
302 | 	}
303 | 
304 | 	class NodeScriptLoader implements IScriptLoader {
305 | 
306 | 		private static _BOM = 0xFEFF;
307 | 		private static _PREFIX = '(function (require, define, __filename, __dirname) { ';
308 | 		private static _SUFFIX = '\n});';
309 | 
310 | 		private readonly _env: Environment;
311 | 
312 | 		private _didPatchNodeRequire: boolean;
313 | 		private _didInitialize: boolean;
314 | 		private _fs: INodeFS;
315 | 		private _vm: INodeVM;
316 | 		private _path: INodePath;
317 | 		private _crypto: INodeCrypto;
318 | 
319 | 		constructor(env: Environment) {
320 | 			this._env = env;
321 | 			this._didInitialize = false;
322 | 			this._didPatchNodeRequire = false;
323 | 		}
324 | 
325 | 		private _init(nodeRequire: (nodeModule: string) => any): void {
326 | 			if (this._didInitialize) {
327 | 				return;
328 | 			}
329 | 			this._didInitialize = true;
330 | 
331 | 			// capture node modules
332 | 			this._fs = nodeRequire('fs');
333 | 			this._vm = nodeRequire('vm');
334 | 			this._path = nodeRequire('path');
335 | 			this._crypto = nodeRequire('crypto');
336 | 		}
337 | 
338 | 		// patch require-function of nodejs such that we can manually create a script
339 | 		// from cached data. this is done by overriding the `Module._compile` function
340 | 		private _initNodeRequire(nodeRequire: (nodeModule: string) => any, moduleManager: IModuleManager): void {
341 | 			// It is important to check for `nodeCachedData` first and then set `_didPatchNodeRequire`.
342 | 			// That's because `nodeCachedData` is set _after_ calling this for the first time...
343 | 			const { nodeCachedData } = moduleManager.getConfig().getOptionsLiteral();
344 | 			if (!nodeCachedData) {
345 | 				return;
346 | 			}
347 | 			if (this._didPatchNodeRequire) {
348 | 				return;
349 | 			}
350 | 			this._didPatchNodeRequire = true;
351 | 
352 | 			const that = this
353 | 			const Module = nodeRequire('module');
354 | 
355 | 			function makeRequireFunction(mod: any) {
356 | 				const Module = mod.constructor;
357 | 				let require = <any>function require(path) {
358 | 					try {
359 | 						return mod.require(path);
360 | 					} finally {
361 | 						// nothing
362 | 					}
363 | 				}
364 | 				require.resolve = function resolve(request, options) {
365 | 					return Module._resolveFilename(request, mod, false, options);
366 | 				};
367 | 				require.resolve.paths = function paths(request) {
368 | 					return Module._resolveLookupPaths(request, mod);
369 | 				};
370 | 				require.main = process.mainModule;
371 | 				require.extensions = Module._extensions;
372 | 				require.cache = Module._cache;
373 | 				return require;
374 | 			}
375 | 
376 | 			Module.prototype._compile = function (content: string, filename: string) {
377 | 				// remove shebang and create wrapper function
378 | 				const scriptSource = Module.wrap(content.replace(/^#!.*/, ''));
379 | 
380 | 				// create script
381 | 				const recorder = moduleManager.getRecorder();
382 | 				const cachedDataPath = that._getCachedDataPath(nodeCachedData, filename);
383 | 				const options: INodeVMScriptOptions = { filename };
384 | 				let hashData: Buffer | undefined;
385 | 				try {
386 | 					const data = that._fs.readFileSync(cachedDataPath);
387 | 					hashData = data.slice(0, 16);
388 | 					options.cachedData = data.slice(16);
389 | 					recorder.record(LoaderEventType.CachedDataFound, cachedDataPath);
390 | 				} catch (_e) {
391 | 					recorder.record(LoaderEventType.CachedDataMissed, cachedDataPath);
392 | 				}
393 | 				const script = new that._vm.Script(scriptSource, options);
394 | 				const compileWrapper = script.runInThisContext(options);
395 | 
396 | 				// run script
397 | 				const dirname = that._path.dirname(filename);
398 | 				const require = makeRequireFunction(this);
399 | 				const args = [this.exports, require, this, filename, dirname, process, _commonjsGlobal, Buffer];
400 | 				const result = compileWrapper.apply(this.exports, args);
401 | 
402 | 				// cached data aftermath
403 | 				that._handleCachedData(script, scriptSource, cachedDataPath, !options.cachedData, moduleManager);
404 | 				that._verifyCachedData(script, scriptSource, cachedDataPath!, hashData, moduleManager);
405 | 
406 | 				return result;
407 | 			}
408 | 		}
409 | 
410 | 		public load(moduleManager: IModuleManager, scriptSrc: string, callback: () => void, errorback: (err: any) => void): void {
411 | 			const opts = moduleManager.getConfig().getOptionsLiteral();
412 | 			const nodeRequire = ensureRecordedNodeRequire(moduleManager.getRecorder(), (opts.nodeRequire || global.nodeRequire));
413 | 			const nodeInstrumenter = (opts.nodeInstrumenter || function (c) { return c; });
414 | 			this._init(nodeRequire);
415 | 			this._initNodeRequire(nodeRequire, moduleManager);
416 | 			let recorder = moduleManager.getRecorder();
417 | 
418 | 			if (/^node\|/.test(scriptSrc)) {
419 | 
420 | 				let pieces = scriptSrc.split('|');
421 | 
422 | 				let moduleExports = null;
423 | 				try {
424 | 					moduleExports = nodeRequire(pieces[1]);
425 | 				} catch (err) {
426 | 					errorback(err);
427 | 					return;
428 | 				}
429 | 
430 | 				moduleManager.enqueueDefineAnonymousModule([], () => moduleExports);
431 | 				callback();
432 | 
433 | 			} else {
434 | 
435 | 				scriptSrc = Utilities.fileUriToFilePath(this._env.isWindows, scriptSrc);
436 | 				const normalizedScriptSrc = this._path.normalize(scriptSrc);
437 | 				const vmScriptPathOrUri = this._getElectronRendererScriptPathOrUri(normalizedScriptSrc);
438 | 				const wantsCachedData = Boolean(opts.nodeCachedData);
439 | 				const cachedDataPath = wantsCachedData ? this._getCachedDataPath(opts.nodeCachedData!, scriptSrc) : undefined;
440 | 
441 | 				this._readSourceAndCachedData(normalizedScriptSrc, cachedDataPath, recorder, (err: any, data: string, cachedData: Buffer, hashData: Buffer) => {
442 | 					if (err) {
443 | 						errorback(err);
444 | 						return;
445 | 					}
446 | 
447 | 					let scriptSource: string;
448 | 					if (data.charCodeAt(0) === NodeScriptLoader._BOM) {
449 | 						scriptSource = NodeScriptLoader._PREFIX + data.substring(1) + NodeScriptLoader._SUFFIX;
450 | 					} else {
451 | 						scriptSource = NodeScriptLoader._PREFIX + data + NodeScriptLoader._SUFFIX;
452 | 					}
453 | 
454 | 					scriptSource = nodeInstrumenter(scriptSource, normalizedScriptSrc);
455 | 					const scriptOpts: INodeVMScriptOptions = { filename: vmScriptPathOrUri, cachedData };
456 | 					const script = this._createAndEvalScript(moduleManager, scriptSource, scriptOpts, callback, errorback);
457 | 
458 | 					this._handleCachedData(script, scriptSource, cachedDataPath!, wantsCachedData && !cachedData, moduleManager);
459 | 					this._verifyCachedData(script, scriptSource, cachedDataPath!, hashData, moduleManager);
460 | 				});
461 | 			}
462 | 		}
463 | 
464 | 		private _createAndEvalScript(moduleManager: IModuleManager, contents: string, options: INodeVMScriptOptions, callback: () => void, errorback: (err: any) => void): INodeVMScript {
465 | 			const recorder = moduleManager.getRecorder();
466 | 			recorder.record(LoaderEventType.NodeBeginEvaluatingScript, options.filename);
467 | 
468 | 			const script = new this._vm.Script(contents, options);
469 | 			const ret = script.runInThisContext(options);
470 | 
471 | 			const globalDefineFunc = moduleManager.getGlobalAMDDefineFunc();
472 | 			let receivedDefineCall = false;
473 | 			const localDefineFunc: IDefineFunc = <any>function () {
474 | 				receivedDefineCall = true;
475 | 				return globalDefineFunc.apply(null, arguments);
476 | 			};
477 | 			localDefineFunc.amd = globalDefineFunc.amd;
478 | 
479 | 			ret.call(global, moduleManager.getGlobalAMDRequireFunc(), localDefineFunc, options.filename, this._path.dirname(options.filename));
480 | 
481 | 			recorder.record(LoaderEventType.NodeEndEvaluatingScript, options.filename);
482 | 
483 | 			if (receivedDefineCall) {
484 | 				callback();
485 | 			} else {
486 | 				errorback(new Error(`Didn't receive define call in ${options.filename}!`));
487 | 			}
488 | 
489 | 			return script;
490 | 		}
491 | 
492 | 		private _getElectronRendererScriptPathOrUri(path: string) {
493 | 			if (!this._env.isElectronRenderer) {
494 | 				return path;
495 | 			}
496 | 			let driveLetterMatch = path.match(/^([a-z])\:(.*)/i);
497 | 			if (driveLetterMatch) {
498 | 				// windows
499 | 				return `file:///${(driveLetterMatch[1].toUpperCase() + ':' + driveLetterMatch[2]).replace(/\\/g, '/')}`;
500 | 			} else {
501 | 				// nix
502 | 				return `file://${path}`;
503 | 			}
504 | 		}
505 | 
506 | 		private _getCachedDataPath(config: INodeCachedDataConfiguration, filename: string): string {
507 | 			const hash = this._crypto.createHash('md5').update(filename, 'utf8').update(config.seed!, 'utf8').update(process.arch, '').digest('hex');
508 | 			const basename = this._path.basename(filename).replace(/\.js$/, '');
509 | 			return this._path.join(config.path, `${basename}-${hash}.code`);
510 | 		}
511 | 
512 | 		private _handleCachedData(script: INodeVMScript, scriptSource: string, cachedDataPath: string, createCachedData: boolean, moduleManager: IModuleManager): void {
513 | 			if (script.cachedDataRejected) {
514 | 				// cached data got rejected -> delete and re-create
515 | 				this._fs.unlink(cachedDataPath, err => {
516 | 					moduleManager.getRecorder().record(LoaderEventType.CachedDataRejected, cachedDataPath);
517 | 					this._createAndWriteCachedData(script, scriptSource, cachedDataPath, moduleManager);
518 | 					if (err) {
519 | 						moduleManager.getConfig().onError(err)
520 | 					}
521 | 				});
522 | 			} else if (createCachedData) {
523 | 				// no cached data, but wanted
524 | 				this._createAndWriteCachedData(script, scriptSource, cachedDataPath, moduleManager);
525 | 			}
526 | 		}
527 | 
528 | 		// Cached data format: | SOURCE_HASH | V8_CACHED_DATA |
529 | 		// -SOURCE_HASH is the md5 hash of the JS source (always 16 bytes)
530 | 		// -V8_CACHED_DATA is what v8 produces
531 | 
532 | 		private _createAndWriteCachedData(script: INodeVMScript, scriptSource: string, cachedDataPath: string, moduleManager: IModuleManager): void {
533 | 
534 | 			let timeout: number = Math.ceil(moduleManager.getConfig().getOptionsLiteral().nodeCachedData!.writeDelay! * (1 + Math.random()));
535 | 			let lastSize: number = -1;
536 | 			let iteration: number = 0;
537 | 			let hashData: Buffer | undefined = undefined;
538 | 
539 | 			const createLoop = () => {
540 | 				setTimeout(() => {
541 | 
542 | 					if (!hashData) {
543 | 						hashData = this._crypto.createHash('md5').update(scriptSource, 'utf8').digest();
544 | 					}
545 | 
546 | 					const cachedData = script.createCachedData();
547 | 					if (cachedData.length === 0 || cachedData.length === lastSize || iteration >= 5) {
548 | 						// done
549 | 						return;
550 | 					}
551 | 
552 | 					if (cachedData.length < lastSize) {
553 | 						// less data than before: skip, try again next round
554 | 						createLoop();
555 | 						return;
556 | 					}
557 | 
558 | 					lastSize = cachedData.length;
559 | 					this._fs.writeFile(cachedDataPath, Buffer.concat([hashData, cachedData]), err => {
560 | 						if (err) {
561 | 							moduleManager.getConfig().onError(err);
562 | 						}
563 | 						moduleManager.getRecorder().record(LoaderEventType.CachedDataCreated, cachedDataPath);
564 | 						createLoop();
565 | 					});
566 | 				}, timeout * (4 ** iteration++));
567 | 			};
568 | 
569 | 			// with some delay (`timeout`) create cached data
570 | 			// and repeat that (with backoff delay) until the
571 | 			// data seems to be not changing anymore
572 | 			createLoop();
573 | 		}
574 | 
575 | 		private _readSourceAndCachedData(sourcePath: string, cachedDataPath: string | undefined, recorder: ILoaderEventRecorder, callback: (err?: any, source?: string, cachedData?: Buffer, hashData?: Buffer) => any): void {
576 | 
577 | 			if (!cachedDataPath) {
578 | 				// no cached data case
579 | 				this._fs.readFile(sourcePath, { encoding: 'utf8' }, callback);
580 | 
581 | 			} else {
582 | 				// cached data case: read both files in parallel
583 | 				let source: string | undefined = undefined;
584 | 				let cachedData: Buffer | undefined = undefined;
585 | 				let hashData: Buffer | undefined = undefined;
586 | 				let steps = 2;
587 | 
588 | 				const step = (err?: any) => {
589 | 					if (err) {
590 | 						callback(err);
591 | 
592 | 					} else if (--steps === 0) {
593 | 						callback(undefined, source, cachedData, hashData);
594 | 					}
595 | 				}
596 | 
597 | 				this._fs.readFile(sourcePath, { encoding: 'utf8' }, (err: any, data: string) => {
598 | 					source = data;
599 | 					step(err);
600 | 				});
601 | 
602 | 				this._fs.readFile(cachedDataPath, (err: any, data: Buffer) => {
603 | 					if (!err && data && data.length > 0) {
604 | 						hashData = data.slice(0, 16);
605 | 						cachedData = data.slice(16);
606 | 						recorder.record(LoaderEventType.CachedDataFound, cachedDataPath);
607 | 
608 | 					} else {
609 | 						recorder.record(LoaderEventType.CachedDataMissed, cachedDataPath);
610 | 					}
611 | 					step(); // ignored: cached data is optional
612 | 				});
613 | 			}
614 | 		}
615 | 
616 | 		private _verifyCachedData(script: INodeVMScript, scriptSource: string, cachedDataPath: string, hashData: Buffer | undefined, moduleManager: IModuleManager): void {
617 | 			if (!hashData) {
618 | 				// nothing to do
619 | 				return;
620 | 			}
621 | 			if (script.cachedDataRejected) {
622 | 				// invalid anyways
623 | 				return;
624 | 			}
625 | 			setTimeout(() => {
626 | 				// check source hash - the contract is that file paths change when file content
627 | 				// change (e.g use the commit or version id as cache path). this check is
628 | 				// for violations of this contract.
629 | 				const hashDataNow = this._crypto.createHash('md5').update(scriptSource, 'utf8').digest();
630 | 				if (!hashData.equals(hashDataNow)) {
631 | 					moduleManager.getConfig().onError(<any>new Error(`FAILED TO VERIFY CACHED DATA, deleting stale '${cachedDataPath}' now, but a RESTART IS REQUIRED`));
632 | 					this._fs.unlink(cachedDataPath!, err => {
633 | 						if (err) {
634 | 							moduleManager.getConfig().onError(err);
635 | 						}
636 | 					});
637 | 				}
638 | 
639 | 			}, Math.ceil(5000 * (1 + Math.random())));
640 | 		}
641 | 	}
642 | 
643 | 	export function ensureRecordedNodeRequire(recorder: ILoaderEventRecorder, _nodeRequire: (nodeModule: string) => any): (nodeModule: string) => any {
644 | 		if ((<any>_nodeRequire).__$__isRecorded) {
645 | 			// it is already recorded
646 | 			return _nodeRequire;
647 | 		}
648 | 
649 | 		const nodeRequire = function nodeRequire(what) {
650 | 			recorder.record(LoaderEventType.NodeBeginNativeRequire, what);
651 | 			try {
652 | 				return _nodeRequire(what);
653 | 			} finally {
654 | 				recorder.record(LoaderEventType.NodeEndNativeRequire, what);
655 | 			}
656 | 		};
657 | 		(<any>nodeRequire).__$__isRecorded = true;
658 | 		return nodeRequire;
659 | 	}
660 | 
661 | 	export function createScriptLoader(env: Environment): IScriptLoader {
662 | 		return new OnlyOnceScriptLoader(env);
663 | 	}
664 | }
665 | 


--------------------------------------------------------------------------------
/src/core/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"compilerOptions": {
 3 | 		"target": "es6",
 4 | 		"newLine": "LF",
 5 | 		"noUnusedLocals": true,
 6 | 		"strictNullChecks": true,
 7 | 		"outFile": "../loader.js",
 8 | 		"declaration": true
 9 | 	},
10 | 	"files": [
11 | 		"env.ts",
12 | 		"loaderEvents.ts",
13 | 		"utils.ts",
14 | 		"configuration.ts",
15 | 		"scriptLoader.ts",
16 | 		"moduleManager.ts",
17 | 		"main.ts"
18 | 	],
19 | 	"exclude": [
20 | 		"node_modules"
21 | 	]
22 | }
23 | 


--------------------------------------------------------------------------------
/src/core/utils.ts:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------------------------
  2 |  *  Copyright (c) Microsoft Corporation. All rights reserved.
  3 |  *  Licensed under the MIT License. See License.txt in the project root for license information.
  4 |  *--------------------------------------------------------------------------------------------*/
  5 | 
  6 | namespace AMDLoader {
  7 | 
  8 | 	export class Utilities {
  9 | 		/**
 10 | 		 * This method does not take care of / vs \
 11 | 		 */
 12 | 		public static fileUriToFilePath(isWindows: boolean, uri: string): string {
 13 | 			uri = decodeURI(uri).replace(/%23/g, '#');
 14 | 			if (isWindows) {
 15 | 				if (/^file:\/\/\//.test(uri)) {
 16 | 					// This is a URI without a hostname => return only the path segment
 17 | 					return uri.substr(8);
 18 | 				}
 19 | 				if (/^file:\/\//.test(uri)) {
 20 | 					return uri.substr(5);
 21 | 				}
 22 | 			} else {
 23 | 				if (/^file:\/\//.test(uri)) {
 24 | 					return uri.substr(7);
 25 | 				}
 26 | 			}
 27 | 			// Not sure...
 28 | 			return uri;
 29 | 		}
 30 | 
 31 | 		public static startsWith(haystack: string, needle: string): boolean {
 32 | 			return haystack.length >= needle.length && haystack.substr(0, needle.length) === needle;
 33 | 		}
 34 | 
 35 | 		public static endsWith(haystack: string, needle: string): boolean {
 36 | 			return haystack.length >= needle.length && haystack.substr(haystack.length - needle.length) === needle;
 37 | 		}
 38 | 
 39 | 		// only check for "?" before "#" to ensure that there is a real Query-String
 40 | 		public static containsQueryString(url: string): boolean {
 41 | 			return /^[^\#]*\?/gi.test(url);
 42 | 		}
 43 | 
 44 | 		/**
 45 | 		 * Does `url` start with http:// or https:// or file:// or / ?
 46 | 		 */
 47 | 		public static isAbsolutePath(url: string): boolean {
 48 | 			return /^((http:\/\/)|(https:\/\/)|(file:\/\/)|(\/))/.test(url);
 49 | 		}
 50 | 
 51 | 		public static forEachProperty(obj: any, callback: (key: string, value: any) => void): void {
 52 | 			if (obj) {
 53 | 				let key: string;
 54 | 				for (key in obj) {
 55 | 					if (obj.hasOwnProperty(key)) {
 56 | 						callback(key, obj[key]);
 57 | 					}
 58 | 				}
 59 | 			}
 60 | 		}
 61 | 
 62 | 		public static isEmpty(obj: any): boolean {
 63 | 			let isEmpty = true;
 64 | 			Utilities.forEachProperty(obj, () => {
 65 | 				isEmpty = false;
 66 | 			});
 67 | 			return isEmpty;
 68 | 		}
 69 | 
 70 | 		public static recursiveClone(obj: any): any {
 71 | 			if (!obj || typeof obj !== 'object' || obj instanceof RegExp) {
 72 | 				return obj;
 73 | 			}
 74 | 			if (!Array.isArray(obj) && Object.getPrototypeOf(obj) !== Object.prototype) {
 75 | 				// only clone "simple" objects
 76 | 				return obj;
 77 | 			}
 78 | 			let result = Array.isArray(obj) ? [] : {};
 79 | 			Utilities.forEachProperty(obj, (key: string, value: any) => {
 80 | 				if (value && typeof value === 'object') {
 81 | 					result[key] = Utilities.recursiveClone(value);
 82 | 				} else {
 83 | 					result[key] = value;
 84 | 				}
 85 | 			});
 86 | 			return result;
 87 | 		}
 88 | 
 89 | 
 90 | 		private static NEXT_ANONYMOUS_ID = 1;
 91 | 
 92 | 		public static generateAnonymousModule(): string {
 93 | 			return '===anonymous' + (Utilities.NEXT_ANONYMOUS_ID++) + '===';
 94 | 		}
 95 | 
 96 | 		public static isAnonymousModule(id: string): boolean {
 97 | 			return Utilities.startsWith(id, '===anonymous');
 98 | 		}
 99 | 
100 | 		private static PERFORMANCE_NOW_PROBED = false;
101 | 		private static HAS_PERFORMANCE_NOW = false;
102 | 
103 | 		public static getHighPerformanceTimestamp(): number {
104 | 			if (!this.PERFORMANCE_NOW_PROBED) {
105 | 				this.PERFORMANCE_NOW_PROBED = true;
106 | 				this.HAS_PERFORMANCE_NOW = (global.performance && typeof global.performance.now === 'function');
107 | 			}
108 | 			return (this.HAS_PERFORMANCE_NOW ? global.performance.now() : Date.now());
109 | 		}
110 | 	}
111 | }
112 | 


--------------------------------------------------------------------------------
/src/loader.d.ts:
--------------------------------------------------------------------------------
  1 | declare const _amdLoaderGlobal: typeof globalThis;
  2 | declare var module: {
  3 |     exports: any;
  4 | };
  5 | declare var process: {
  6 |     platform: string;
  7 |     type: string;
  8 |     mainModule: string;
  9 |     arch: string;
 10 |     argv: string[];
 11 |     versions: {
 12 |         node: string;
 13 |         electron: string;
 14 |     };
 15 | };
 16 | declare var require: {
 17 |     nodeRequire(module: string): any;
 18 | };
 19 | declare var global: object;
 20 | declare const _commonjsGlobal: object;
 21 | declare namespace AMDLoader {
 22 |     const global: any;
 23 |     class Environment {
 24 |         private _detected;
 25 |         private _isWindows;
 26 |         private _isNode;
 27 |         private _isElectronRenderer;
 28 |         private _isWebWorker;
 29 |         private _isElectronNodeIntegrationWebWorker;
 30 |         get isWindows(): boolean;
 31 |         get isNode(): boolean;
 32 |         get isElectronRenderer(): boolean;
 33 |         get isWebWorker(): boolean;
 34 |         get isElectronNodeIntegrationWebWorker(): boolean;
 35 |         constructor();
 36 |         private _detect;
 37 |         private static _isWindows;
 38 |     }
 39 | }
 40 | declare namespace AMDLoader {
 41 |     const enum LoaderEventType {
 42 |         LoaderAvailable = 1,
 43 |         BeginLoadingScript = 10,
 44 |         EndLoadingScriptOK = 11,
 45 |         EndLoadingScriptError = 12,
 46 |         BeginInvokeFactory = 21,
 47 |         EndInvokeFactory = 22,
 48 |         NodeBeginEvaluatingScript = 31,
 49 |         NodeEndEvaluatingScript = 32,
 50 |         NodeBeginNativeRequire = 33,
 51 |         NodeEndNativeRequire = 34,
 52 |         CachedDataFound = 60,
 53 |         CachedDataMissed = 61,
 54 |         CachedDataRejected = 62,
 55 |         CachedDataCreated = 63
 56 |     }
 57 |     class LoaderEvent {
 58 |         type: LoaderEventType;
 59 |         timestamp: number;
 60 |         detail: string;
 61 |         constructor(type: LoaderEventType, detail: string, timestamp: number);
 62 |     }
 63 |     interface ILoaderEventRecorder {
 64 |         record(type: LoaderEventType, detail: string): void;
 65 |         getEvents(): LoaderEvent[];
 66 |     }
 67 |     class LoaderEventRecorder implements ILoaderEventRecorder {
 68 |         private _events;
 69 |         constructor(loaderAvailableTimestamp: number);
 70 |         record(type: LoaderEventType, detail: string): void;
 71 |         getEvents(): LoaderEvent[];
 72 |     }
 73 |     class NullLoaderEventRecorder implements ILoaderEventRecorder {
 74 |         static INSTANCE: NullLoaderEventRecorder;
 75 |         record(type: LoaderEventType, detail: string): void;
 76 |         getEvents(): LoaderEvent[];
 77 |     }
 78 | }
 79 | declare namespace AMDLoader {
 80 |     class Utilities {
 81 |         /**
 82 |          * This method does not take care of / vs \
 83 |          */
 84 |         static fileUriToFilePath(isWindows: boolean, uri: string): string;
 85 |         static startsWith(haystack: string, needle: string): boolean;
 86 |         static endsWith(haystack: string, needle: string): boolean;
 87 |         static containsQueryString(url: string): boolean;
 88 |         /**
 89 |          * Does `url` start with http:// or https:// or file:// or / ?
 90 |          */
 91 |         static isAbsolutePath(url: string): boolean;
 92 |         static forEachProperty(obj: any, callback: (key: string, value: any) => void): void;
 93 |         static isEmpty(obj: any): boolean;
 94 |         static recursiveClone(obj: any): any;
 95 |         private static NEXT_ANONYMOUS_ID;
 96 |         static generateAnonymousModule(): string;
 97 |         static isAnonymousModule(id: string): boolean;
 98 |         private static PERFORMANCE_NOW_PROBED;
 99 |         private static HAS_PERFORMANCE_NOW;
100 |         static getHighPerformanceTimestamp(): number;
101 |     }
102 | }
103 | declare namespace AMDLoader {
104 |     interface AnnotatedLoadingError extends Error {
105 |         phase: 'loading';
106 |         moduleId: string;
107 |         neededBy: string[];
108 |     }
109 |     interface AnnotatedFactoryError extends Error {
110 |         phase: 'factory';
111 |         moduleId: string;
112 |         neededBy: string[];
113 |     }
114 |     interface AnnotatedValidationError extends Error {
115 |         phase: 'configuration';
116 |     }
117 |     type AnnotatedError = AnnotatedLoadingError | AnnotatedFactoryError | AnnotatedValidationError;
118 |     function ensureError<T extends Error>(err: any): T;
119 |     /**
120 |      * The signature for the loader's AMD "define" function.
121 |      */
122 |     interface IDefineFunc {
123 |         (id: 'string', dependencies: string[], callback: any): void;
124 |         (id: 'string', callback: any): void;
125 |         (dependencies: string[], callback: any): void;
126 |         (callback: any): void;
127 |         amd: {
128 |             jQuery: boolean;
129 |         };
130 |     }
131 |     /**
132 |      * The signature for the loader's AMD "require" function.
133 |      */
134 |     interface IRequireFunc {
135 |         (module: string): any;
136 |         (config: any): void;
137 |         (modules: string[], callback: Function): void;
138 |         (modules: string[], callback: Function, errorback: (err: any) => void): void;
139 |         config(params: IConfigurationOptions, shouldOverwrite?: boolean): void;
140 |         getConfig(): IConfigurationOptions;
141 |         /**
142 |          * Non standard extension to reset completely the loader state. This is used for running amdjs tests
143 |          */
144 |         reset(): void;
145 |         /**
146 |          * Non standard extension to fetch loader state for building purposes.
147 |          */
148 |         getBuildInfo(): IBuildModuleInfo[] | null;
149 |         /**
150 |          * Non standard extension to fetch loader events
151 |          */
152 |         getStats(): LoaderEvent[];
153 |         /**
154 |          * The define function
155 |          */
156 |         define(id: 'string', dependencies: string[], callback: any): void;
157 |         define(id: 'string', callback: any): void;
158 |         define(dependencies: string[], callback: any): void;
159 |         define(callback: any): void;
160 |         moduleManager?: ModuleManager;
161 |     }
162 |     interface IModuleConfiguration {
163 |         [key: string]: any;
164 |     }
165 |     interface INodeRequire {
166 |         (nodeModule: string): any;
167 |         main: {
168 |             filename: string;
169 |         };
170 |     }
171 |     interface INodeCachedDataConfiguration {
172 |         /**
173 |          * Directory path in which cached is stored.
174 |          */
175 |         path: string;
176 |         /**
177 |          * Seed when generating names of cache files.
178 |          */
179 |         seed?: string;
180 |         /**
181 |          * Optional delay for filesystem write/delete operations
182 |          */
183 |         writeDelay?: number;
184 |     }
185 |     interface IConfigurationOptions {
186 |         /**
187 |          * Allow module ids to end with .js
188 |          */
189 |         allowJsExtension?: boolean;
190 |         /**
191 |          * The prefix that will be aplied to all modules when they are resolved to a location
192 |          */
193 |         baseUrl?: string;
194 |         /**
195 |          * Redirect rules for modules. The redirect rules will affect the module ids themselves
196 |          */
197 |         paths?: {
198 |             [path: string]: any;
199 |         };
200 |         /**
201 |          * Per-module configuration
202 |          */
203 |         config?: {
204 |             [moduleId: string]: IModuleConfiguration;
205 |         };
206 |         /**
207 |          * Catch errors when invoking the module factories
208 |          */
209 |         catchError?: boolean;
210 |         /**
211 |          * Record statistics
212 |          */
213 |         recordStats?: boolean;
214 |         /**
215 |          * The suffix that will be aplied to all modules when they are resolved to a location
216 |          */
217 |         urlArgs?: string;
218 |         /**
219 |          * Callback that will be called when errors are encountered
220 |          */
221 |         onError?: (err: AnnotatedError) => void;
222 |         /**
223 |          * The loader will issue warnings when duplicate modules are encountered.
224 |          * This list will inhibit those warnings if duplicate modules are expected.
225 |          */
226 |         ignoreDuplicateModules?: string[];
227 |         /**
228 |          * Flag to indicate if current execution is as part of a build. Used by plugins
229 |          */
230 |         isBuild?: boolean;
231 |         /**
232 |          * Normally, during a build, no module factories are invoked. This can be used
233 |          * to forcefully execute a module's factory.
234 |          */
235 |         buildForceInvokeFactory?: {
236 |             [moduleId: string]: boolean;
237 |         };
238 |         /**
239 |          * Content Security Policy nonce value used to load child scripts.
240 |          */
241 |         cspNonce?: string;
242 |         /**
243 |          * If running inside an electron renderer, prefer using <script> tags to load code.
244 |          * Defaults to false.
245 |          */
246 |         preferScriptTags?: boolean;
247 |         /**
248 |          * A trusted types policy which will be used to create TrustedScriptURL-values.
249 |          * https://w3c.github.io/webappsec-trusted-types/dist/spec/#introduction.
250 |          */
251 |         trustedTypesPolicy?: {
252 |             createScriptURL(value: string): string & object;
253 |             createScript(_: string, value: string): string;
254 |         };
255 |         /**
256 |          * A regex to help determine if a module is an AMD module or a node module.
257 |          * If defined, then all amd modules in the system must match this regular expression.
258 |          */
259 |         amdModulesPattern?: RegExp;
260 |         /**
261 |          * The main entry point node's require
262 |          */
263 |         nodeRequire?: INodeRequire;
264 |         /**
265 |          * An optional transformation applied to the source before it is loaded in node's vm
266 |          */
267 |         nodeInstrumenter?: (source: string, vmScriptSrc: string) => string;
268 |         /**
269 |         * Support v8 cached data (http://v8project.blogspot.co.uk/2015/07/code-caching.html)
270 |         */
271 |         nodeCachedData?: INodeCachedDataConfiguration;
272 |     }
273 |     interface IValidatedConfigurationOptions extends IConfigurationOptions {
274 |         allowJsExtension: boolean;
275 |         baseUrl: string;
276 |         paths: {
277 |             [path: string]: any;
278 |         };
279 |         config: {
280 |             [moduleId: string]: IModuleConfiguration;
281 |         };
282 |         catchError: boolean;
283 |         recordStats: boolean;
284 |         urlArgs: string;
285 |         onError: (err: AnnotatedError) => void;
286 |         ignoreDuplicateModules: string[];
287 |         isBuild: boolean;
288 |         cspNonce: string;
289 |         preferScriptTags: boolean;
290 |     }
291 |     class ConfigurationOptionsUtil {
292 |         /**
293 |          * Ensure configuration options make sense
294 |          */
295 |         private static validateConfigurationOptions;
296 |         static mergeConfigurationOptions(overwrite?: IConfigurationOptions | null, base?: IConfigurationOptions | null): IValidatedConfigurationOptions;
297 |     }
298 |     class Configuration {
299 |         private readonly _env;
300 |         private options;
301 |         /**
302 |          * Generated from the `ignoreDuplicateModules` configuration option.
303 |          */
304 |         private ignoreDuplicateModulesMap;
305 |         /**
306 |          * Generated from the `paths` configuration option. These are sorted with the longest `from` first.
307 |          */
308 |         private sortedPathsRules;
309 |         constructor(env: Environment, options?: IConfigurationOptions);
310 |         private _createIgnoreDuplicateModulesMap;
311 |         private _createSortedPathsRules;
312 |         /**
313 |          * Clone current configuration and overwrite options selectively.
314 |          * @param options The selective options to overwrite with.
315 |          * @result A new configuration
316 |          */
317 |         cloneAndMerge(options?: IConfigurationOptions): Configuration;
318 |         /**
319 |          * Get current options bag. Useful for passing it forward to plugins.
320 |          */
321 |         getOptionsLiteral(): IValidatedConfigurationOptions;
322 |         private _applyPaths;
323 |         private _addUrlArgsToUrl;
324 |         private _addUrlArgsIfNecessaryToUrl;
325 |         private _addUrlArgsIfNecessaryToUrls;
326 |         /**
327 |          * Transform a module id to a location. Appends .js to module ids
328 |          */
329 |         moduleIdToPaths(moduleIdOrPath: string): string[];
330 |         /**
331 |          * Transform a module id or url to a location.
332 |          */
333 |         requireToUrl(url: string): string;
334 |         /**
335 |          * Flag to indicate if current execution is as part of a build.
336 |          */
337 |         isBuild(): boolean;
338 |         shouldInvokeFactory(strModuleId: string): boolean;
339 |         /**
340 |          * Test if module `moduleId` is expected to be defined multiple times
341 |          */
342 |         isDuplicateMessageIgnoredFor(moduleId: string): boolean;
343 |         /**
344 |          * Get the configuration settings for the provided module id
345 |          */
346 |         getConfigForModule(moduleId: string): IModuleConfiguration | undefined;
347 |         /**
348 |          * Should errors be caught when executing module factories?
349 |          */
350 |         shouldCatchError(): boolean;
351 |         /**
352 |          * Should statistics be recorded?
353 |          */
354 |         shouldRecordStats(): boolean;
355 |         /**
356 |          * Forward an error to the error handler.
357 |          */
358 |         onError(err: AnnotatedError): void;
359 |     }
360 | }
361 | declare namespace AMDLoader {
362 |     interface IModuleManager {
363 |         getGlobalAMDDefineFunc(): IDefineFunc;
364 |         getGlobalAMDRequireFunc(): IRequireFunc;
365 |         getConfig(): Configuration;
366 |         enqueueDefineAnonymousModule(dependencies: string[], callback: any): void;
367 |         getRecorder(): ILoaderEventRecorder;
368 |     }
369 |     interface IScriptLoader {
370 |         load(moduleManager: IModuleManager, scriptPath: string, loadCallback: () => void, errorCallback: (err: any) => void): void;
371 |     }
372 |     function ensureRecordedNodeRequire(recorder: ILoaderEventRecorder, _nodeRequire: (nodeModule: string) => any): (nodeModule: string) => any;
373 |     function createScriptLoader(env: Environment): IScriptLoader;
374 | }
375 | declare namespace AMDLoader {
376 |     interface ILoaderPlugin {
377 |         load: (pluginParam: string, parentRequire: IRelativeRequire, loadCallback: IPluginLoadCallback, options: IConfigurationOptions) => void;
378 |     }
379 |     interface IDefineCall {
380 |         stack: string | null;
381 |         dependencies: string[];
382 |         callback: any;
383 |     }
384 |     interface IRelativeRequire {
385 |         (dependencies: string[], callback: Function, errorback?: (error: Error) => void): void;
386 |         (dependency: string): any;
387 |         toUrl(id: string): string;
388 |         getStats(): LoaderEvent[];
389 |         hasDependencyCycle(): boolean;
390 |         getChecksums(): {
391 |             [scriptSrc: string]: string;
392 |         };
393 |         config(params: IConfigurationOptions, shouldOverwrite?: boolean): void;
394 |     }
395 |     interface IPluginLoadCallback {
396 |         (value: any): void;
397 |         error(err: any): void;
398 |     }
399 |     interface IPluginWriteCallback {
400 |         (contents: string): void;
401 |         getEntryPoint(): string;
402 |         asModule(moduleId: string, contents: string): void;
403 |     }
404 |     interface IPluginWriteFileCallback {
405 |         (filename: string, contents: string): void;
406 |         getEntryPoint(): string;
407 |         asModule(moduleId: string, contents: string): void;
408 |     }
409 |     class ModuleIdResolver {
410 |         static ROOT: ModuleIdResolver;
411 |         private fromModulePath;
412 |         constructor(fromModuleId: string);
413 |         /**
414 |          * Normalize 'a/../name' to 'name', etc.
415 |          */
416 |         static _normalizeModuleId(moduleId: string): string;
417 |         /**
418 |          * Resolve relative module ids
419 |          */
420 |         resolveModule(moduleId: string): string;
421 |     }
422 |     class Module {
423 |         readonly id: ModuleId;
424 |         readonly strId: string;
425 |         readonly dependencies: Dependency[] | null;
426 |         private readonly _callback;
427 |         private readonly _errorback;
428 |         readonly moduleIdResolver: ModuleIdResolver | null;
429 |         exports: any;
430 |         error: AnnotatedError | null;
431 |         exportsPassedIn: boolean;
432 |         unresolvedDependenciesCount: number;
433 |         private _isComplete;
434 |         constructor(id: ModuleId, strId: string, dependencies: Dependency[], callback: any, errorback: ((err: AnnotatedError) => void) | null | undefined, moduleIdResolver: ModuleIdResolver | null);
435 |         private static _safeInvokeFunction;
436 |         private static _invokeFactory;
437 |         complete(recorder: ILoaderEventRecorder, config: Configuration, dependenciesValues: any[], inversedependenciesProvider: (moduleId: number) => string[]): void;
438 |         /**
439 |          * One of the direct dependencies or a transitive dependency has failed to load.
440 |          */
441 |         onDependencyError(err: AnnotatedError): boolean;
442 |         /**
443 |          * Is the current module complete?
444 |          */
445 |         isComplete(): boolean;
446 |     }
447 |     interface IPosition {
448 |         line: number;
449 |         col: number;
450 |     }
451 |     interface IBuildModuleInfo {
452 |         id: string;
453 |         path: string | null;
454 |         defineLocation: IPosition | null;
455 |         dependencies: string[];
456 |         shim: string | null;
457 |         exports: any;
458 |     }
459 |     const enum ModuleId {
460 |         EXPORTS = 0,
461 |         MODULE = 1,
462 |         REQUIRE = 2
463 |     }
464 |     class RegularDependency {
465 |         static EXPORTS: RegularDependency;
466 |         static MODULE: RegularDependency;
467 |         static REQUIRE: RegularDependency;
468 |         readonly id: ModuleId;
469 |         constructor(id: ModuleId);
470 |     }
471 |     class PluginDependency {
472 |         readonly id: ModuleId;
473 |         readonly pluginId: ModuleId;
474 |         readonly pluginParam: string;
475 |         constructor(id: ModuleId, pluginId: ModuleId, pluginParam: string);
476 |     }
477 |     type Dependency = RegularDependency | PluginDependency;
478 |     class ModuleManager {
479 |         private readonly _env;
480 |         private readonly _scriptLoader;
481 |         private readonly _loaderAvailableTimestamp;
482 |         private readonly _defineFunc;
483 |         private readonly _requireFunc;
484 |         private _moduleIdProvider;
485 |         private _config;
486 |         private _hasDependencyCycle;
487 |         /**
488 |          * map of module id => module.
489 |          * If a module is found in _modules, its code has been loaded, but
490 |          * not necessary all its dependencies have been resolved
491 |          */
492 |         private _modules2;
493 |         /**
494 |          * Set of module ids => true
495 |          * If a module is found in _knownModules, a call has been made
496 |          * to the scriptLoader to load its code or a call will be made
497 |          * This is mainly used as a flag to not try loading the same module twice
498 |          */
499 |         private _knownModules2;
500 |         /**
501 |          * map of module id => array [module id]
502 |          */
503 |         private _inverseDependencies2;
504 |         /**
505 |          * Hash map of module id => array [ { moduleId, pluginParam } ]
506 |          */
507 |         private _inversePluginDependencies2;
508 |         /**
509 |          * current annonymous received define call, but not yet processed
510 |          */
511 |         private _currentAnonymousDefineCall;
512 |         private _recorder;
513 |         private _buildInfoPath;
514 |         private _buildInfoDefineStack;
515 |         private _buildInfoDependencies;
516 |         constructor(env: Environment, scriptLoader: IScriptLoader, defineFunc: IDefineFunc, requireFunc: IRequireFunc | null, loaderAvailableTimestamp?: number);
517 |         reset(): ModuleManager;
518 |         getGlobalAMDDefineFunc(): IDefineFunc;
519 |         getGlobalAMDRequireFunc(): IRequireFunc;
520 |         private static _findRelevantLocationInStack;
521 |         getBuildInfo(): IBuildModuleInfo[] | null;
522 |         getRecorder(): ILoaderEventRecorder;
523 |         getLoaderEvents(): LoaderEvent[];
524 |         /**
525 |          * Defines an anonymous module (without an id). Its name will be resolved as we receive a callback from the scriptLoader.
526 |          * @param dependencies @see defineModule
527 |          * @param callback @see defineModule
528 |          */
529 |         enqueueDefineAnonymousModule(dependencies: string[], callback: any): void;
530 |         /**
531 |          * Creates a module and stores it in _modules. The manager will immediately begin resolving its dependencies.
532 |          * @param strModuleId An unique and absolute id of the module. This must not collide with another module's id
533 |          * @param dependencies An array with the dependencies of the module. Special keys are: "require", "exports" and "module"
534 |          * @param callback if callback is a function, it will be called with the resolved dependencies. if callback is an object, it will be considered as the exports of the module.
535 |          */
536 |         defineModule(strModuleId: string, dependencies: string[], callback: any, errorback: ((err: AnnotatedError) => void) | null | undefined, stack: string | null, moduleIdResolver?: ModuleIdResolver): void;
537 |         private _normalizeDependency;
538 |         private _normalizeDependencies;
539 |         private _relativeRequire;
540 |         /**
541 |          * Require synchronously a module by its absolute id. If the module is not loaded, an exception will be thrown.
542 |          * @param id The unique and absolute id of the required module
543 |          * @return The exports of module 'id'
544 |          */
545 |         synchronousRequire(_strModuleId: string, moduleIdResolver?: ModuleIdResolver): any;
546 |         configure(params: IConfigurationOptions, shouldOverwrite: boolean): void;
547 |         getConfig(): Configuration;
548 |         /**
549 |          * Callback from the scriptLoader when a module has been loaded.
550 |          * This means its code is available and has been executed.
551 |          */
552 |         private _onLoad;
553 |         private _createLoadError;
554 |         /**
555 |          * Callback from the scriptLoader when a module hasn't been loaded.
556 |          * This means that the script was not found (e.g. 404) or there was an error in the script.
557 |          */
558 |         private _onLoadError;
559 |         /**
560 |          * Walks (recursively) the dependencies of 'from' in search of 'to'.
561 |          * Returns true if there is such a path or false otherwise.
562 |          * @param from Module id to start at
563 |          * @param to Module id to look for
564 |          */
565 |         private _hasDependencyPath;
566 |         /**
567 |          * Walks (recursively) the dependencies of 'from' in search of 'to'.
568 |          * Returns cycle as array.
569 |          * @param from Module id to start at
570 |          * @param to Module id to look for
571 |          */
572 |         private _findCyclePath;
573 |         /**
574 |          * Create the local 'require' that is passed into modules
575 |          */
576 |         private _createRequire;
577 |         private _loadModule;
578 |         /**
579 |          * Resolve a plugin dependency with the plugin loaded & complete
580 |          * @param module The module that has this dependency
581 |          * @param pluginDependency The semi-normalized dependency that appears in the module. e.g. 'vs/css!./mycssfile'. Only the plugin part (before !) is normalized
582 |          * @param plugin The plugin (what the plugin exports)
583 |          */
584 |         private _loadPluginDependency;
585 |         /**
586 |          * Examine the dependencies of module 'module' and resolve them as needed.
587 |          */
588 |         private _resolve;
589 |         private _onModuleComplete;
590 |     }
591 | }
592 | declare var doNotInitLoader: any;
593 | declare var define: any;
594 | declare namespace AMDLoader {
595 |     function init(): void;
596 | }
597 | 


--------------------------------------------------------------------------------
/tests/loader.test.js:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------------------------
  2 |  *  Copyright (c) Microsoft Corporation. All rights reserved.
  3 |  *  Licensed under the MIT License. See License.txt in the project root for license information.
  4 |  *--------------------------------------------------------------------------------------------*/
  5 | var loader = AMDLoader;
  6 | QUnit.module('ConfigurationOptionsUtil');
  7 | /**
  8 |  * Assert that two configuration options are equal and disregard `onError`
  9 |  */
 10 | function assertConfigurationIs(actual, expected) {
 11 |     actual.onError = null;
 12 |     actual.nodeCachedData = null;
 13 |     expected.onError = null;
 14 |     expected.nodeCachedData = null;
 15 |     QUnit.deepEqual(actual, expected, 'Configuration options are equal');
 16 | }
 17 | QUnit.test('Default configuration', () => {
 18 |     var result = loader.ConfigurationOptionsUtil.mergeConfigurationOptions();
 19 |     assertConfigurationIs(result, {
 20 |         allowJsExtension: false,
 21 |         baseUrl: '',
 22 |         catchError: false,
 23 |         ignoreDuplicateModules: [],
 24 |         isBuild: false,
 25 |         paths: {},
 26 |         config: {},
 27 |         urlArgs: '',
 28 |         cspNonce: '',
 29 |         preferScriptTags: false,
 30 |         recordStats: false
 31 |     });
 32 | });
 33 | function createSimpleKnownConfigurationOptions() {
 34 |     return loader.ConfigurationOptionsUtil.mergeConfigurationOptions({
 35 |         allowJsExtension: false,
 36 |         baseUrl: 'myBaseUrl',
 37 |         catchError: true,
 38 |         ignoreDuplicateModules: ['a'],
 39 |         isBuild: false,
 40 |         paths: { 'a': 'b' },
 41 |         config: { 'd': {} },
 42 |         urlArgs: 'myUrlArgs',
 43 |         cspNonce: '',
 44 |         preferScriptTags: false,
 45 |         recordStats: false
 46 |     });
 47 | }
 48 | QUnit.test('Simple known configuration options', () => {
 49 |     var result = createSimpleKnownConfigurationOptions();
 50 |     assertConfigurationIs(result, {
 51 |         allowJsExtension: false,
 52 |         baseUrl: 'myBaseUrl/',
 53 |         catchError: true,
 54 |         ignoreDuplicateModules: ['a'],
 55 |         isBuild: false,
 56 |         paths: { 'a': 'b' },
 57 |         config: { 'd': {} },
 58 |         urlArgs: 'myUrlArgs',
 59 |         cspNonce: '',
 60 |         preferScriptTags: false,
 61 |         recordStats: false
 62 |     });
 63 | });
 64 | QUnit.test('Overwriting known configuration options', () => {
 65 |     // Overwrite baseUrl 1
 66 |     var result = loader.ConfigurationOptionsUtil.mergeConfigurationOptions({
 67 |         baseUrl: ''
 68 |     }, createSimpleKnownConfigurationOptions());
 69 |     assertConfigurationIs(result, {
 70 |         allowJsExtension: false,
 71 |         baseUrl: '',
 72 |         catchError: true,
 73 |         ignoreDuplicateModules: ['a'],
 74 |         isBuild: false,
 75 |         paths: { 'a': 'b' },
 76 |         config: { 'd': {} },
 77 |         urlArgs: 'myUrlArgs',
 78 |         cspNonce: '',
 79 |         preferScriptTags: false,
 80 |         recordStats: false
 81 |     });
 82 |     // Overwrite baseUrl 2
 83 |     result = loader.ConfigurationOptionsUtil.mergeConfigurationOptions({
 84 |         baseUrl: '/'
 85 |     }, createSimpleKnownConfigurationOptions());
 86 |     assertConfigurationIs(result, {
 87 |         allowJsExtension: false,
 88 |         baseUrl: '/',
 89 |         catchError: true,
 90 |         ignoreDuplicateModules: ['a'],
 91 |         isBuild: false,
 92 |         paths: { 'a': 'b' },
 93 |         config: { 'd': {} },
 94 |         urlArgs: 'myUrlArgs',
 95 |         cspNonce: '',
 96 |         preferScriptTags: false,
 97 |         recordStats: false
 98 |     });
 99 |     // Overwrite catchError
100 |     result = loader.ConfigurationOptionsUtil.mergeConfigurationOptions({
101 |         catchError: false
102 |     }, createSimpleKnownConfigurationOptions());
103 |     assertConfigurationIs(result, {
104 |         allowJsExtension: false,
105 |         baseUrl: 'myBaseUrl/',
106 |         catchError: false,
107 |         ignoreDuplicateModules: ['a'],
108 |         isBuild: false,
109 |         paths: { 'a': 'b' },
110 |         config: { 'd': {} },
111 |         urlArgs: 'myUrlArgs',
112 |         cspNonce: '',
113 |         preferScriptTags: false,
114 |         recordStats: false
115 |     });
116 |     // Contribute additional ignoreDuplicateModules
117 |     result = loader.ConfigurationOptionsUtil.mergeConfigurationOptions({
118 |         ignoreDuplicateModules: ['b']
119 |     }, createSimpleKnownConfigurationOptions());
120 |     assertConfigurationIs(result, {
121 |         allowJsExtension: false,
122 |         baseUrl: 'myBaseUrl/',
123 |         catchError: true,
124 |         ignoreDuplicateModules: ['a', 'b'],
125 |         isBuild: false,
126 |         paths: { 'a': 'b' },
127 |         config: { 'd': {} },
128 |         urlArgs: 'myUrlArgs',
129 |         cspNonce: '',
130 |         preferScriptTags: false,
131 |         recordStats: false
132 |     });
133 |     // Change defined paths
134 |     result = loader.ConfigurationOptionsUtil.mergeConfigurationOptions({
135 |         paths: { 'a': 'c' }
136 |     }, createSimpleKnownConfigurationOptions());
137 |     assertConfigurationIs(result, {
138 |         allowJsExtension: false,
139 |         baseUrl: 'myBaseUrl/',
140 |         catchError: true,
141 |         ignoreDuplicateModules: ['a'],
142 |         isBuild: false,
143 |         paths: { 'a': 'c' },
144 |         config: { 'd': {} },
145 |         urlArgs: 'myUrlArgs',
146 |         cspNonce: '',
147 |         preferScriptTags: false,
148 |         recordStats: false
149 |     });
150 |     // Contribute additional module configs
151 |     result = loader.ConfigurationOptionsUtil.mergeConfigurationOptions({
152 |         config: { 'e': {} }
153 |     }, createSimpleKnownConfigurationOptions());
154 |     assertConfigurationIs(result, {
155 |         allowJsExtension: false,
156 |         baseUrl: 'myBaseUrl/',
157 |         catchError: true,
158 |         ignoreDuplicateModules: ['a'],
159 |         isBuild: false,
160 |         paths: { 'a': 'b' },
161 |         config: { 'd': {}, 'e': {} },
162 |         urlArgs: 'myUrlArgs',
163 |         cspNonce: '',
164 |         preferScriptTags: false,
165 |         recordStats: false
166 |     });
167 |     // Change defined module configs
168 |     result = loader.ConfigurationOptionsUtil.mergeConfigurationOptions({
169 |         config: { 'd': { 'a': 'a' } }
170 |     }, createSimpleKnownConfigurationOptions());
171 |     assertConfigurationIs(result, {
172 |         allowJsExtension: false,
173 |         baseUrl: 'myBaseUrl/',
174 |         catchError: true,
175 |         ignoreDuplicateModules: ['a'],
176 |         isBuild: false,
177 |         paths: { 'a': 'b' },
178 |         config: { 'd': { 'a': 'a' } },
179 |         urlArgs: 'myUrlArgs',
180 |         cspNonce: '',
181 |         preferScriptTags: false,
182 |         recordStats: false
183 |     });
184 | });
185 | QUnit.test('Overwriting unknown configuration options', () => {
186 |     var result = loader.ConfigurationOptionsUtil.mergeConfigurationOptions();
187 |     assertConfigurationIs(result, {
188 |         allowJsExtension: false,
189 |         baseUrl: '',
190 |         catchError: false,
191 |         ignoreDuplicateModules: [],
192 |         isBuild: false,
193 |         paths: {},
194 |         config: {},
195 |         urlArgs: '',
196 |         cspNonce: '',
197 |         preferScriptTags: false,
198 |         recordStats: false
199 |     });
200 |     // Adding unknown key
201 |     result = loader.ConfigurationOptionsUtil.mergeConfigurationOptions({
202 |         unknownKey1: 'value1'
203 |     }, result);
204 |     assertConfigurationIs(result, {
205 |         allowJsExtension: false,
206 |         baseUrl: '',
207 |         catchError: false,
208 |         ignoreDuplicateModules: [],
209 |         isBuild: false,
210 |         paths: {},
211 |         config: {},
212 |         urlArgs: '',
213 |         cspNonce: '',
214 |         preferScriptTags: false,
215 |         recordStats: false,
216 |         unknownKey1: 'value1'
217 |     });
218 |     // Adding another unknown key
219 |     result = loader.ConfigurationOptionsUtil.mergeConfigurationOptions({
220 |         unknownKey2: 'value2'
221 |     }, result);
222 |     assertConfigurationIs(result, {
223 |         allowJsExtension: false,
224 |         baseUrl: '',
225 |         catchError: false,
226 |         ignoreDuplicateModules: [],
227 |         isBuild: false,
228 |         paths: {},
229 |         config: {},
230 |         urlArgs: '',
231 |         cspNonce: '',
232 |         preferScriptTags: false,
233 |         recordStats: false,
234 |         unknownKey1: 'value1',
235 |         unknownKey2: 'value2'
236 |     });
237 |     // Overwriting unknown key
238 |     result = loader.ConfigurationOptionsUtil.mergeConfigurationOptions({
239 |         unknownKey2: 'new-value2'
240 |     }, result);
241 |     assertConfigurationIs(result, {
242 |         allowJsExtension: false,
243 |         baseUrl: '',
244 |         catchError: false,
245 |         ignoreDuplicateModules: [],
246 |         isBuild: false,
247 |         paths: {},
248 |         config: {},
249 |         urlArgs: '',
250 |         cspNonce: '',
251 |         preferScriptTags: false,
252 |         recordStats: false,
253 |         unknownKey1: 'value1',
254 |         unknownKey2: 'new-value2'
255 |     });
256 | });
257 | QUnit.module('Configuration');
258 | QUnit.test('moduleIdToPath', () => {
259 |     var config = new loader.Configuration(new loader.Environment(), {
260 |         baseUrl: 'prefix',
261 |         urlArgs: 'suffix',
262 |         paths: {
263 |             'a': 'newa',
264 |             'knockout': 'http://ajax.aspnetcdn.com/ajax/knockout/knockout-2.2.1.js',
265 |             'editor': '/src/editor'
266 |         }
267 |     });
268 |     // baseUrl is applied
269 |     QUnit.equal(config.moduleIdToPaths('b/c/d'), 'prefix/b/c/d.js?suffix');
270 |     // paths rules are applied
271 |     QUnit.equal(config.moduleIdToPaths('a'), 'prefix/newa.js?suffix');
272 |     QUnit.equal(config.moduleIdToPaths('a/b/c/d'), 'prefix/newa/b/c/d.js?suffix');
273 |     // paths rules check if value is an absolute path
274 |     QUnit.equal(config.moduleIdToPaths('knockout'), 'http://ajax.aspnetcdn.com/ajax/knockout/knockout-2.2.1.js?suffix');
275 |     // modules ending in .js skip baseUrl + paths rules
276 |     QUnit.equal(config.moduleIdToPaths('b/c/d.js'), 'b/c/d.js?suffix');
277 |     QUnit.equal(config.moduleIdToPaths('a/b/c/d.js'), 'a/b/c/d.js?suffix');
278 |     QUnit.equal(config.moduleIdToPaths('a.js'), 'a.js?suffix');
279 |     // modules redirected to / still get .js appended
280 |     QUnit.equal(config.moduleIdToPaths('editor/x'), '/src/editor/x.js?suffix');
281 |     // modules starting with / skip baseUrl + paths rules
282 |     QUnit.equal(config.moduleIdToPaths('/b/c/d'), '/b/c/d.js?suffix');
283 |     QUnit.equal(config.moduleIdToPaths('/a/b/c/d'), '/a/b/c/d.js?suffix');
284 |     QUnit.equal(config.moduleIdToPaths('/a'), '/a.js?suffix');
285 |     // modules starting with http:// or https:// skip baseUrl + paths rules
286 |     QUnit.equal(config.moduleIdToPaths('file:///c:/a/b/c'), 'file:///c:/a/b/c.js?suffix');
287 |     QUnit.equal(config.moduleIdToPaths('http://b/c/d'), 'http://b/c/d.js?suffix');
288 |     QUnit.equal(config.moduleIdToPaths('http://a/b/c/d'), 'http://a/b/c/d.js?suffix');
289 |     QUnit.equal(config.moduleIdToPaths('http://a'), 'http://a.js?suffix');
290 |     QUnit.equal(config.moduleIdToPaths('https://b/c/d'), 'https://b/c/d.js?suffix');
291 |     QUnit.equal(config.moduleIdToPaths('https://a/b/c/d'), 'https://a/b/c/d.js?suffix');
292 |     QUnit.equal(config.moduleIdToPaths('https://a'), 'https://a.js?suffix');
293 | });
294 | QUnit.test('moduleIdToPath with allowJsExtension', () => {
295 |     var config = new loader.Configuration(new loader.Environment(), {
296 |         allowJsExtension: true,
297 |         baseUrl: 'prefix',
298 |         urlArgs: 'suffix',
299 |         paths: {
300 |             'a': 'newa',
301 |             'knockout': 'http://ajax.aspnetcdn.com/ajax/knockout/knockout-2.2.1.js',
302 |             'knockout.js': 'http://ajax.aspnetcdn.com/ajax/knockout/knockout-2.2.1.js',
303 |             'editor': '/src/editor'
304 |         }
305 |     });
306 |     // baseUrl is applied
307 |     QUnit.equal(config.moduleIdToPaths('b/c/d'), 'prefix/b/c/d.js?suffix');
308 |     QUnit.equal(config.moduleIdToPaths('b/c/d.js'), 'prefix/b/c/d.js?suffix');
309 |     // paths rules are applied
310 |     QUnit.equal(config.moduleIdToPaths('a'), 'prefix/newa.js?suffix');
311 |     QUnit.equal(config.moduleIdToPaths('a.js'), 'prefix/newa.js?suffix');
312 |     QUnit.equal(config.moduleIdToPaths('a/b/c/d'), 'prefix/newa/b/c/d.js?suffix');
313 |     QUnit.equal(config.moduleIdToPaths('a/b/c/d.js'), 'prefix/newa/b/c/d.js?suffix');
314 |     // paths rules check if value is an absolute path
315 |     QUnit.equal(config.moduleIdToPaths('knockout'), 'http://ajax.aspnetcdn.com/ajax/knockout/knockout-2.2.1.js?suffix');
316 |     QUnit.equal(config.moduleIdToPaths('knockout.js'), 'http://ajax.aspnetcdn.com/ajax/knockout/knockout-2.2.1.js?suffix');
317 |     // modules redirected to / still get .js appended
318 |     QUnit.equal(config.moduleIdToPaths('editor/x'), '/src/editor/x.js?suffix');
319 |     QUnit.equal(config.moduleIdToPaths('editor/x.js'), '/src/editor/x.js?suffix');
320 |     // modules starting with / skip baseUrl + paths rules
321 |     QUnit.equal(config.moduleIdToPaths('/b/c/d'), '/b/c/d.js?suffix');
322 |     QUnit.equal(config.moduleIdToPaths('/b/c/d.js'), '/b/c/d.js?suffix');
323 |     QUnit.equal(config.moduleIdToPaths('/a/b/c/d'), '/a/b/c/d.js?suffix');
324 |     QUnit.equal(config.moduleIdToPaths('/a/b/c/d.js'), '/a/b/c/d.js?suffix');
325 |     QUnit.equal(config.moduleIdToPaths('/a'), '/a.js?suffix');
326 |     QUnit.equal(config.moduleIdToPaths('/a.js'), '/a.js?suffix');
327 |     // modules starting with http:// or https:// skip baseUrl + paths rules
328 |     QUnit.equal(config.moduleIdToPaths('file:///c:/a/b/c'), 'file:///c:/a/b/c.js?suffix');
329 |     QUnit.equal(config.moduleIdToPaths('file:///c:/a/b/c.js'), 'file:///c:/a/b/c.js?suffix');
330 |     QUnit.equal(config.moduleIdToPaths('http://b/c/d'), 'http://b/c/d.js?suffix');
331 |     QUnit.equal(config.moduleIdToPaths('http://b/c/d.js'), 'http://b/c/d.js?suffix');
332 |     QUnit.equal(config.moduleIdToPaths('http://a/b/c/d'), 'http://a/b/c/d.js?suffix');
333 |     QUnit.equal(config.moduleIdToPaths('http://a/b/c/d.js'), 'http://a/b/c/d.js?suffix');
334 |     QUnit.equal(config.moduleIdToPaths('http://a'), 'http://a.js?suffix');
335 |     QUnit.equal(config.moduleIdToPaths('http://a.js'), 'http://a.js?suffix');
336 |     QUnit.equal(config.moduleIdToPaths('https://b/c/d'), 'https://b/c/d.js?suffix');
337 |     QUnit.equal(config.moduleIdToPaths('https://b/c/d.js'), 'https://b/c/d.js?suffix');
338 |     QUnit.equal(config.moduleIdToPaths('https://a/b/c/d'), 'https://a/b/c/d.js?suffix');
339 |     QUnit.equal(config.moduleIdToPaths('https://a/b/c/d.js'), 'https://a/b/c/d.js?suffix');
340 |     QUnit.equal(config.moduleIdToPaths('https://a'), 'https://a.js?suffix');
341 |     QUnit.equal(config.moduleIdToPaths('https://a.js'), 'https://a.js?suffix');
342 | });
343 | QUnit.test('requireToUrl', () => {
344 |     var config = new loader.Configuration(new loader.Environment(), {
345 |         baseUrl: 'prefix',
346 |         urlArgs: 'suffix',
347 |         paths: {
348 |             'a': 'newa'
349 |         }
350 |     });
351 |     // baseUrl is applied
352 |     QUnit.equal(config.requireToUrl('b/c/d'), 'prefix/b/c/d?suffix');
353 |     QUnit.equal(config.requireToUrl('../a/b/c/d'), 'prefix/../a/b/c/d?suffix');
354 |     // paths rules are applied
355 |     QUnit.equal(config.requireToUrl('a'), 'prefix/newa?suffix');
356 |     QUnit.equal(config.requireToUrl('a/b/c/d'), 'prefix/newa/b/c/d?suffix');
357 |     // urls ending in .js get no special treatment
358 |     QUnit.equal(config.requireToUrl('b/c/d.js'), 'prefix/b/c/d.js?suffix');
359 |     QUnit.equal(config.requireToUrl('a/b/c/d.js'), 'prefix/newa/b/c/d.js?suffix');
360 |     QUnit.equal(config.requireToUrl('a.js'), 'prefix/newa.js?suffix');
361 |     // requireToUrl does not append .js
362 |     QUnit.equal(config.requireToUrl('b/c/d.png'), 'prefix/b/c/d.png?suffix');
363 |     QUnit.equal(config.requireToUrl('a/b/c/d.png'), 'prefix/newa/b/c/d.png?suffix');
364 |     QUnit.equal(config.requireToUrl('a.png'), 'prefix/newa.png?suffix');
365 |     // urls starting with / skip baseUrl + paths rules
366 |     QUnit.equal(config.requireToUrl('/b/c/d'), '/b/c/d?suffix');
367 |     QUnit.equal(config.requireToUrl('/a/b/c/d'), '/a/b/c/d?suffix');
368 |     QUnit.equal(config.requireToUrl('/a'), '/a?suffix');
369 |     // urls starting with http:// or https:// skip baseUrl + paths rules
370 |     QUnit.equal(config.requireToUrl('http://b/c/d'), 'http://b/c/d?suffix');
371 |     QUnit.equal(config.requireToUrl('http://a/b/c/d'), 'http://a/b/c/d?suffix');
372 |     QUnit.equal(config.requireToUrl('http://a'), 'http://a?suffix');
373 |     QUnit.equal(config.requireToUrl('https://b/c/d'), 'https://b/c/d?suffix');
374 |     QUnit.equal(config.requireToUrl('https://a/b/c/d'), 'https://a/b/c/d?suffix');
375 |     QUnit.equal(config.requireToUrl('https://a'), 'https://a?suffix');
376 | });
377 | QUnit.test('ignoreDuplicateModules', () => {
378 |     var config = new loader.Configuration(new loader.Environment(), {
379 |         ignoreDuplicateModules: ['a1', 'a2', 'a/b/c']
380 |     });
381 |     QUnit.equal(config.isDuplicateMessageIgnoredFor('a1'), true);
382 |     QUnit.equal(config.isDuplicateMessageIgnoredFor('a2'), true);
383 |     QUnit.equal(config.isDuplicateMessageIgnoredFor('a/b/c'), true);
384 |     QUnit.equal(config.isDuplicateMessageIgnoredFor('a'), false);
385 | });
386 | QUnit.module('ModuleIdResolver');
387 | QUnit.test('resolveModule', () => {
388 |     var resolver = new loader.ModuleIdResolver('a/b/c/d');
389 |     // normal modules
390 |     QUnit.equal(resolver.resolveModule('e/f/g'), 'e/f/g');
391 |     QUnit.equal(resolver.resolveModule('e/f/../f/g'), 'e/f/../f/g');
392 |     // normal modules ending in .js
393 |     QUnit.equal(resolver.resolveModule('e/f/g.js'), 'e/f/g.js');
394 |     // relative modules
395 |     QUnit.equal(resolver.resolveModule('./e/f/g'), 'a/b/c/e/f/g');
396 |     QUnit.equal(resolver.resolveModule('../e/f/g'), 'a/b/e/f/g');
397 |     QUnit.equal(resolver.resolveModule('../../e/f/g'), 'a/e/f/g');
398 |     QUnit.equal(resolver.resolveModule('../../../e/f/g'), 'e/f/g');
399 |     QUnit.equal(resolver.resolveModule('../../../../e/f/g'), '../e/f/g');
400 |     QUnit.equal(resolver.resolveModule('../b/../c/d'), 'a/b/c/d');
401 |     // relative modules ending in .js
402 |     QUnit.equal(resolver.resolveModule('./e/f/g.js'), 'a/b/c/e/f/g.js');
403 |     QUnit.equal(resolver.resolveModule('../e/f/g.js'), 'a/b/e/f/g.js');
404 |     QUnit.equal(resolver.resolveModule('../../e/f/g.js'), 'a/e/f/g.js');
405 |     QUnit.equal(resolver.resolveModule('../../../e/f/g.js'), 'e/f/g.js');
406 |     QUnit.equal(resolver.resolveModule('../../../../e/f/g.js'), '../e/f/g.js');
407 |     // modules starting with /
408 |     QUnit.equal(resolver.resolveModule('/b/c/d'), '/b/c/d');
409 |     QUnit.equal(resolver.resolveModule('/a'), '/a');
410 |     QUnit.equal(resolver.resolveModule('/a/b/c/d.js'), '/a/b/c/d.js');
411 |     QUnit.equal(resolver.resolveModule('/../a/b/c'), '/../a/b/c');
412 |     // modules starting with http:// or https://
413 |     QUnit.equal(resolver.resolveModule('http://b/c/d'), 'http://b/c/d');
414 |     QUnit.equal(resolver.resolveModule('http://a'), 'http://a');
415 |     QUnit.equal(resolver.resolveModule('http://a/b/c/d.js'), 'http://a/b/c/d.js');
416 |     QUnit.equal(resolver.resolveModule('https://b/c/d'), 'https://b/c/d');
417 |     QUnit.equal(resolver.resolveModule('https://a'), 'https://a');
418 |     QUnit.equal(resolver.resolveModule('https://a/b/c/d.js'), 'https://a/b/c/d.js');
419 |     // modules starting with file://
420 |     QUnit.equal(resolver.resolveModule('file://b/c/d'), 'file://b/c/d');
421 |     QUnit.equal(resolver.resolveModule('file://a'), 'file://a');
422 |     QUnit.equal(resolver.resolveModule('file://a/b/c/d.js'), 'file://a/b/c/d.js');
423 |     QUnit.equal(loader.ModuleIdResolver._normalizeModuleId('./a'), 'a');
424 |     QUnit.equal(loader.ModuleIdResolver._normalizeModuleId('./././a'), 'a');
425 |     QUnit.equal(loader.ModuleIdResolver._normalizeModuleId('a/b/c/d/../../../../../e/f/g/h'), '../e/f/g/h');
426 |     QUnit.equal(loader.ModuleIdResolver._normalizeModuleId('file:///c:/a/b/c/d/e.f.g/h/./j'), 'file:///c:/a/b/c/d/e.f.g/h/j');
427 |     QUnit.equal(loader.ModuleIdResolver._normalizeModuleId('../../ab/../a'), '../../a');
428 | });
429 | QUnit.module('ModuleManager');
430 | QUnit.test('Loading 3 simple modules', () => {
431 |     QUnit.expect(3);
432 |     var scriptLoader = {
433 |         load: (moduleManager, scriptPath, loadCallback, errorCallback) => {
434 |             if (scriptPath === 'a1.js') {
435 |                 mm.enqueueDefineAnonymousModule([], 'a1');
436 |                 loadCallback();
437 |             }
438 |             else if (scriptPath === 'a2.js') {
439 |                 mm.defineModule('a2', [], 'a2', null, null);
440 |                 loadCallback();
441 |             }
442 |             else {
443 |                 QUnit.ok(false);
444 |             }
445 |         },
446 |     };
447 |     var mm = new loader.ModuleManager(new loader.Environment(), scriptLoader, null, null);
448 |     mm.defineModule('a', ['a1', 'a2'], (a1, a2) => {
449 |         QUnit.equal(a1, 'a1');
450 |         QUnit.equal(a2, 'a2');
451 |         return 'a';
452 |     }, null, null);
453 |     QUnit.equal(mm.synchronousRequire('a'), 'a');
454 | });
455 | QUnit.test('Loading a plugin dependency', () => {
456 |     QUnit.expect(5);
457 |     var scriptLoader = {
458 |         load: (moduleManager, scriptPath, loadCallback, errorCallback) => {
459 |             if (scriptPath === 'plugin.js') {
460 |                 mm.enqueueDefineAnonymousModule([], {
461 |                     normalize: (pluginParam, normalize) => {
462 |                         return normalize(pluginParam);
463 |                     },
464 |                     load: (pluginParam, parentRequire, loadCallback, options) => {
465 |                         parentRequire([pluginParam], (v) => loadCallback(v));
466 |                     }
467 |                 });
468 |                 loadCallback();
469 |             }
470 |             else if (scriptPath === 'a/b/d.js') {
471 |                 mm.enqueueDefineAnonymousModule([], 'r');
472 |                 loadCallback();
473 |             }
474 |             else {
475 |                 QUnit.ok(false, 'Unexpected scriptPath: ' + scriptPath);
476 |             }
477 |         },
478 |     };
479 |     var mm = new loader.ModuleManager(new loader.Environment(), scriptLoader, null, null);
480 |     mm.defineModule('a/b/c', ['../../plugin!./d', 'require'], (r, req) => {
481 |         QUnit.equal(r, 'r');
482 |         QUnit.equal(req.toUrl('./d.txt'), 'a/b/d.txt');
483 |         return 'a/b/c';
484 |     }, null, null);
485 |     QUnit.equal(mm.synchronousRequire('a/b/c'), 'a/b/c');
486 |     mm.defineModule('a2', ['./plugin!a/b/d'], (r) => {
487 |         QUnit.equal(r, 'r');
488 |         return 'a2';
489 |     }, null, null);
490 |     QUnit.equal(mm.synchronousRequire('a2'), 'a2');
491 | });
492 | QUnit.test('Loading a dependency cycle', () => {
493 |     QUnit.expect(6);
494 |     var scriptLoader = {
495 |         load: (moduleManager, scriptPath, loadCallback, errorCallback) => {
496 |             if (scriptPath === 'b.js') {
497 |                 mm.enqueueDefineAnonymousModule(['c'], (c) => {
498 |                     // This is how the cycle is broken. One of the modules receives undefined as the argument value
499 |                     QUnit.equal(c, 'c');
500 |                     return 'b';
501 |                 });
502 |                 loadCallback();
503 |             }
504 |             else if (scriptPath === 'c.js') {
505 |                 mm.enqueueDefineAnonymousModule(['a'], (a) => {
506 |                     // This is how the cycle is broken. One of the modules receives undefined as the argument value
507 |                     QUnit.deepEqual(a, {});
508 |                     // QUnit.ok(typeof a === 'undefined');
509 |                     return 'c';
510 |                 });
511 |                 loadCallback();
512 |             }
513 |             else {
514 |                 QUnit.ok(false, 'Unexpected scriptPath: ' + scriptPath);
515 |             }
516 |         },
517 |     };
518 |     var mm = new loader.ModuleManager(new loader.Environment(), scriptLoader, null, null);
519 |     mm.defineModule('a', ['b'], (b) => {
520 |         QUnit.equal(b, 'b');
521 |         return 'a';
522 |     }, null, null);
523 |     QUnit.equal(mm.synchronousRequire('a'), 'a');
524 |     QUnit.equal(mm.synchronousRequire('b'), 'b');
525 |     QUnit.equal(mm.synchronousRequire('c'), 'c');
526 | });
527 | QUnit.test('Using a local error handler immediate script loading failure', () => {
528 |     QUnit.expect(1);
529 |     // a -> b and b fails to load
530 |     var scriptLoader = {
531 |         load: (moduleManager, scriptPath, loadCallback, errorCallback) => {
532 |             if (scriptPath === 'b.js') {
533 |                 errorCallback('b.js not found');
534 |             }
535 |             else {
536 |                 QUnit.ok(false, 'Unexpected scriptPath: ' + scriptPath);
537 |             }
538 |         },
539 |     };
540 |     var mm = new loader.ModuleManager(new loader.Environment(), scriptLoader, null, null);
541 |     mm.defineModule('a', ['b'], (b) => {
542 |         QUnit.equal(b, 'b');
543 |         return 'a';
544 |     }, (err) => {
545 |         QUnit.equal(err.message, 'b.js not found');
546 |     }, null);
547 | });
548 | QUnit.test('Using a local error handler secondary script loading failure', () => {
549 |     QUnit.expect(1);
550 |     // a -> b -> c and c fails to load
551 |     var scriptLoader = {
552 |         load: (moduleManager, scriptPath, loadCallback, errorCallback) => {
553 |             if (scriptPath === 'b.js') {
554 |                 mm.enqueueDefineAnonymousModule(['c'], (c) => {
555 |                     QUnit.equal(c, 'c');
556 |                     return 'b';
557 |                 });
558 |                 loadCallback();
559 |             }
560 |             else if (scriptPath === 'c.js') {
561 |                 errorCallback('c.js not found');
562 |             }
563 |             else {
564 |                 QUnit.ok(false, 'Unexpected scriptPath: ' + scriptPath);
565 |             }
566 |         },
567 |     };
568 |     var mm = new loader.ModuleManager(new loader.Environment(), scriptLoader, null, null);
569 |     mm.defineModule('a', ['b'], (b) => {
570 |         QUnit.ok(false);
571 |     }, (err) => {
572 |         QUnit.equal(err.message, 'c.js not found');
573 |     }, null);
574 | });
575 | QUnit.test('RelativeRequire error handler', () => {
576 |     QUnit.expect(1);
577 |     const dne = 'Does not exist';
578 |     var scriptLoader = {
579 |         load: (moduleManager, scriptPath, loadCallback, errorCallback) => {
580 |             errorCallback(new Error(dne));
581 |         },
582 |     };
583 |     var mm = new loader.ModuleManager(new loader.Environment(), scriptLoader, null, null);
584 |     mm.defineModule('a/b/d', ['require'], (relativeRequire) => {
585 |         relativeRequire(['doesnotexist'], undefined, (err) => {
586 |             QUnit.deepEqual(err.message, dne);
587 |         });
588 |         return 'a/b/d';
589 |     }, null, null);
590 | });
591 | QUnit.module('FallBack Tests');
592 | QUnit.test('No path config', () => {
593 |     QUnit.expect(1);
594 |     var scriptLoader = {
595 |         load: (moduleManager, scriptPath, loadCallback, errorCallback) => {
596 |             if (scriptPath === 'a.js') {
597 |                 errorCallback('a.js not found');
598 |             }
599 |             else {
600 |                 QUnit.ok(false, 'Unexpected scriptPath: ' + scriptPath);
601 |             }
602 |         },
603 |     };
604 |     var mm = new loader.ModuleManager(new loader.Environment(), scriptLoader, null, null);
605 |     mm.defineModule('first', ['a'], () => {
606 |         QUnit.ok(false, 'a should not be found');
607 |     }, (err) => {
608 |         QUnit.ok(true, 'a should not be found');
609 |     }, null);
610 | });
611 | QUnit.test('With path config', () => {
612 |     QUnit.expect(1);
613 |     var scriptLoader = {
614 |         load: (moduleManager, scriptPath, loadCallback, errorCallback) => {
615 |             if (scriptPath === 'alocation.js') {
616 |                 errorCallback('alocation.js not found');
617 |             }
618 |             else {
619 |                 QUnit.ok(false, 'Unexpected scriptPath: ' + scriptPath);
620 |             }
621 |         },
622 |     };
623 |     var mm = new loader.ModuleManager(new loader.Environment(), scriptLoader, null, null);
624 |     mm.configure({
625 |         paths: {
626 |             a: 'alocation.js'
627 |         }
628 |     }, false);
629 |     mm.defineModule('first', ['a'], () => {
630 |         QUnit.ok(false, 'a should not be found');
631 |     }, (err) => {
632 |         QUnit.ok(true, 'a should not be found');
633 |     }, null);
634 | });
635 | QUnit.test('With one fallback', () => {
636 |     QUnit.expect(1);
637 |     var scriptLoader = {
638 |         load: (moduleManager, scriptPath, loadCallback, errorCallback) => {
639 |             if (scriptPath === 'alocation.js') {
640 |                 errorCallback('alocation.js not found');
641 |             }
642 |             else if (scriptPath === 'afallback.js') {
643 |                 mm.enqueueDefineAnonymousModule([], () => {
644 |                     return 'a';
645 |                 });
646 |                 loadCallback();
647 |             }
648 |             else {
649 |                 QUnit.ok(false, 'Unexpected scriptPath: ' + scriptPath);
650 |             }
651 |         },
652 |     };
653 |     var mm = new loader.ModuleManager(new loader.Environment(), scriptLoader, null, null);
654 |     mm.configure({
655 |         paths: {
656 |             a: ['alocation.js', 'afallback.js']
657 |         }
658 |     }, false);
659 |     mm.defineModule('first', ['a'], () => {
660 |         QUnit.ok(true, 'a was found');
661 |     }, (err) => {
662 |         QUnit.ok(false, 'a was not found');
663 |     }, null);
664 | });
665 | QUnit.test('With two fallbacks', () => {
666 |     QUnit.expect(1);
667 |     var scriptLoader = {
668 |         load: (moduleManager, scriptPath, loadCallback, errorCallback) => {
669 |             if (scriptPath === 'alocation.js') {
670 |                 errorCallback('alocation.js not found');
671 |             }
672 |             else if (scriptPath === 'afallback.js') {
673 |                 errorCallback('afallback.js not found');
674 |             }
675 |             else if (scriptPath === 'anotherfallback.js') {
676 |                 mm.enqueueDefineAnonymousModule([], () => {
677 |                     return 'a';
678 |                 });
679 |                 loadCallback();
680 |             }
681 |             else {
682 |                 QUnit.ok(false, 'Unexpected scriptPath: ' + scriptPath);
683 |             }
684 |         },
685 |     };
686 |     var mm = new loader.ModuleManager(new loader.Environment(), scriptLoader, null, null);
687 |     mm.configure({
688 |         paths: {
689 |             a: ['alocation.js', 'afallback.js', 'anotherfallback.js']
690 |         }
691 |     }, false);
692 |     mm.defineModule('first', ['a'], () => {
693 |         QUnit.ok(true, 'a was found');
694 |     }, (err) => {
695 |         QUnit.ok(false, 'a was not found');
696 |     }, null);
697 | });
698 | QUnit.module('Bugs');
699 | QUnit.test('Bug #11710: [loader] Loader can enter a stale-mate when the last dependency to resolve is a (missing) plugin dependency', () => {
700 |     QUnit.expect(2);
701 |     // A script loader that captures the load request for 'plugin.js'
702 |     var scriptLoader = {
703 |         load: (moduleManager, scriptPath, loadCallback, errorCallback) => {
704 |             QUnit.ok(false, 'Unexpected scriptPath: ' + scriptPath);
705 |         },
706 |     };
707 |     var mm = new loader.ModuleManager(new loader.Environment(), scriptLoader, null, null);
708 |     // Define the resolved plugin value
709 |     mm.defineModule('plugin!pluginParam', [], () => {
710 |         return {
711 |             value: 5
712 |         };
713 |     }, (err) => {
714 |         QUnit.ok(false);
715 |     }, null);
716 |     // Ask for the plugin
717 |     mm.defineModule('a', ['plugin!pluginParam'], (b) => {
718 |         QUnit.equal(b.value, 5);
719 |         return {
720 |             value: b.value * 2
721 |         };
722 |     }, (err) => {
723 |         QUnit.ok(false);
724 |     }, null);
725 |     // Depend on a module that asks for the plugin
726 |     mm.defineModule('b', ['a'], (a) => {
727 |         QUnit.equal(a.value, 10);
728 |     }, (err) => {
729 |         QUnit.ok(false);
730 |     }, null);
731 | });
732 | QUnit.test('Bug #12024: [loader] Should not append .js to URLs containing query string', () => {
733 |     var config = new loader.Configuration(new loader.Environment(), {
734 |         baseUrl: 'prefix',
735 |         paths: {
736 |             'searchBoxJss': 'http://services.social.microsoft.com/search/Widgets/SearchBox.jss?boxid=HeaderSearchTextBox&btnid=HeaderSearchButton&brand=Msdn&loc=en-us&Refinement=198,234&focusOnInit=false&iroot=vscom&emptyWatermark=true&searchButtonTooltip=Search here'
737 |         }
738 |     });
739 |     // No .js is appended
740 |     QUnit.equal(config.moduleIdToPaths('searchBoxJss'), 'http://services.social.microsoft.com/search/Widgets/SearchBox.jss?boxid=HeaderSearchTextBox&btnid=HeaderSearchButton&brand=Msdn&loc=en-us&Refinement=198,234&focusOnInit=false&iroot=vscom&emptyWatermark=true&searchButtonTooltip=Search here');
741 | });
742 | QUnit.test('Bug #12020: [loader] relative (synchronous) require does not normalize plugin argument that follows "!"', () => {
743 |     QUnit.expect(3);
744 |     var scriptLoader = {
745 |         load: (moduleManager, scriptPath, loadCallback, errorCallback) => {
746 |             QUnit.ok(false, 'Unexpected scriptPath: ' + scriptPath);
747 |         },
748 |     };
749 |     var mm = new loader.ModuleManager(new loader.Environment(), scriptLoader, null, null);
750 |     mm.defineModule('plugin!a/b/c', [], () => {
751 |         QUnit.ok(true);
752 |         return 'plugin!a/b/c';
753 |     }, null, null);
754 |     mm.defineModule('a/b/d', ['require'], (relativeRequire) => {
755 |         QUnit.ok(true);
756 |         QUnit.equal(relativeRequire('plugin!./c'), 'plugin!a/b/c');
757 |         return 'a/b/d';
758 |     }, null, null);
759 | });
760 | QUnit.test('Utilities.fileUriToFilePath', () => {
761 |     var test = (isWindows, input, expected) => {
762 |         QUnit.equal(loader.Utilities.fileUriToFilePath(isWindows, input), expected, 'Result for ' + input);
763 |     };
764 |     test(true, 'file:///c:/alex.txt', 'c:/alex.txt');
765 |     test(true, 'file://monacotools/isi.txt', '//monacotools/isi.txt');
766 |     test(true, 'file://monacotools1/certificates/SSL/', '//monacotools1/certificates/SSL/');
767 |     test(false, 'file:///c:/alex.txt', '/c:/alex.txt');
768 |     test(false, 'file://monacotools/isi.txt', 'monacotools/isi.txt');
769 |     test(false, 'file://monacotools1/certificates/SSL/', 'monacotools1/certificates/SSL/');
770 | });
771 | QUnit.test('Utilities.containsQueryString', () => {
772 |     var test = (input, expected) => {
773 |         QUnit.equal(loader.Utilities.containsQueryString(input), expected, 'Result for ' + input);
774 |     };
775 |     test('http://www.microsoft.com/something?q=123&r=345#bangbang', true);
776 |     test('http://www.microsoft.com/something#bangbang', false);
777 |     test('http://www.microsoft.com/something#bangbang?asd=3', false);
778 |     test('http://www.microsoft.com/something#?asd=3', false);
779 | });
780 | 


--------------------------------------------------------------------------------
/tests/loader.test.ts:
--------------------------------------------------------------------------------
  1 | /*---------------------------------------------------------------------------------------------
  2 |  *  Copyright (c) Microsoft Corporation. All rights reserved.
  3 |  *  Licensed under the MIT License. See License.txt in the project root for license information.
  4 |  *--------------------------------------------------------------------------------------------*/
  5 | 
  6 | import loader = AMDLoader;
  7 | 
  8 | QUnit.module('ConfigurationOptionsUtil');
  9 | 
 10 | /**
 11 |  * Assert that two configuration options are equal and disregard `onError`
 12 |  */
 13 | function assertConfigurationIs(actual: loader.IConfigurationOptions, expected: loader.IConfigurationOptions): void {
 14 | 	actual.onError = null;
 15 | 	actual.nodeCachedData = null;
 16 | 	expected.onError = null;
 17 | 	expected.nodeCachedData = null;
 18 | 	QUnit.deepEqual(actual, expected, 'Configuration options are equal');
 19 | }
 20 | 
 21 | QUnit.test('Default configuration', () => {
 22 | 	var result = loader.ConfigurationOptionsUtil.mergeConfigurationOptions();
 23 | 	assertConfigurationIs(result, {
 24 | 		allowJsExtension: false,
 25 | 		baseUrl: '',
 26 | 		catchError: false,
 27 | 		ignoreDuplicateModules: [],
 28 | 		isBuild: false,
 29 | 		paths: {},
 30 | 		config: {},
 31 | 		urlArgs: '',
 32 | 		cspNonce: '',
 33 | 		preferScriptTags: false,
 34 | 		recordStats: false
 35 | 	});
 36 | });
 37 | 
 38 | function createSimpleKnownConfigurationOptions(): loader.IConfigurationOptions {
 39 | 	return loader.ConfigurationOptionsUtil.mergeConfigurationOptions({
 40 | 		allowJsExtension: false,
 41 | 		baseUrl: 'myBaseUrl',
 42 | 		catchError: true,
 43 | 		ignoreDuplicateModules: ['a'],
 44 | 		isBuild: false,
 45 | 		paths: { 'a': 'b' },
 46 | 		config: { 'd': {} },
 47 | 		urlArgs: 'myUrlArgs',
 48 | 		cspNonce: '',
 49 | 		preferScriptTags: false,
 50 | 		recordStats: false
 51 | 	});
 52 | }
 53 | 
 54 | QUnit.test('Simple known configuration options', () => {
 55 | 	var result = createSimpleKnownConfigurationOptions();
 56 | 	assertConfigurationIs(result, {
 57 | 		allowJsExtension: false,
 58 | 		baseUrl: 'myBaseUrl/',
 59 | 		catchError: true,
 60 | 		ignoreDuplicateModules: ['a'],
 61 | 		isBuild: false,
 62 | 		paths: { 'a': 'b' },
 63 | 		config: { 'd': {} },
 64 | 		urlArgs: 'myUrlArgs',
 65 | 		cspNonce: '',
 66 | 		preferScriptTags: false,
 67 | 		recordStats: false
 68 | 	});
 69 | });
 70 | 
 71 | QUnit.test('Overwriting known configuration options', () => {
 72 | 	// Overwrite baseUrl 1
 73 | 	var result = loader.ConfigurationOptionsUtil.mergeConfigurationOptions({
 74 | 		baseUrl: ''
 75 | 	}, createSimpleKnownConfigurationOptions());
 76 | 	assertConfigurationIs(result, {
 77 | 		allowJsExtension: false,
 78 | 		baseUrl: '',
 79 | 		catchError: true,
 80 | 		ignoreDuplicateModules: ['a'],
 81 | 		isBuild: false,
 82 | 		paths: { 'a': 'b' },
 83 | 		config: { 'd': {} },
 84 | 		urlArgs: 'myUrlArgs',
 85 | 		cspNonce: '',
 86 | 		preferScriptTags: false,
 87 | 		recordStats: false
 88 | 	});
 89 | 
 90 | 	// Overwrite baseUrl 2
 91 | 	result = loader.ConfigurationOptionsUtil.mergeConfigurationOptions({
 92 | 		baseUrl: '/'
 93 | 	}, createSimpleKnownConfigurationOptions());
 94 | 	assertConfigurationIs(result, {
 95 | 		allowJsExtension: false,
 96 | 		baseUrl: '/',
 97 | 		catchError: true,
 98 | 		ignoreDuplicateModules: ['a'],
 99 | 		isBuild: false,
100 | 		paths: { 'a': 'b' },
101 | 		config: { 'd': {} },
102 | 		urlArgs: 'myUrlArgs',
103 | 		cspNonce: '',
104 | 		preferScriptTags: false,
105 | 		recordStats: false
106 | 	});
107 | 
108 | 	// Overwrite catchError
109 | 	result = loader.ConfigurationOptionsUtil.mergeConfigurationOptions({
110 | 		catchError: false
111 | 	}, createSimpleKnownConfigurationOptions());
112 | 	assertConfigurationIs(result, {
113 | 		allowJsExtension: false,
114 | 		baseUrl: 'myBaseUrl/',
115 | 		catchError: false,
116 | 		ignoreDuplicateModules: ['a'],
117 | 		isBuild: false,
118 | 		paths: { 'a': 'b' },
119 | 		config: { 'd': {} },
120 | 		urlArgs: 'myUrlArgs',
121 | 		cspNonce: '',
122 | 		preferScriptTags: false,
123 | 		recordStats: false
124 | 	});
125 | 
126 | 	// Contribute additional ignoreDuplicateModules
127 | 	result = loader.ConfigurationOptionsUtil.mergeConfigurationOptions({
128 | 		ignoreDuplicateModules: ['b']
129 | 	}, createSimpleKnownConfigurationOptions());
130 | 	assertConfigurationIs(result, {
131 | 		allowJsExtension: false,
132 | 		baseUrl: 'myBaseUrl/',
133 | 		catchError: true,
134 | 		ignoreDuplicateModules: ['a', 'b'],
135 | 		isBuild: false,
136 | 		paths: { 'a': 'b' },
137 | 		config: { 'd': {} },
138 | 		urlArgs: 'myUrlArgs',
139 | 		cspNonce: '',
140 | 		preferScriptTags: false,
141 | 		recordStats: false
142 | 	});
143 | 
144 | 	// Change defined paths
145 | 	result = loader.ConfigurationOptionsUtil.mergeConfigurationOptions({
146 | 		paths: { 'a': 'c' }
147 | 	}, createSimpleKnownConfigurationOptions());
148 | 	assertConfigurationIs(result, {
149 | 		allowJsExtension: false,
150 | 		baseUrl: 'myBaseUrl/',
151 | 		catchError: true,
152 | 		ignoreDuplicateModules: ['a'],
153 | 		isBuild: false,
154 | 		paths: { 'a': 'c' },
155 | 		config: { 'd': {} },
156 | 		urlArgs: 'myUrlArgs',
157 | 		cspNonce: '',
158 | 		preferScriptTags: false,
159 | 		recordStats: false
160 | 	});
161 | 
162 | 	// Contribute additional module configs
163 | 	result = loader.ConfigurationOptionsUtil.mergeConfigurationOptions({
164 | 		config: { 'e': {} }
165 | 	}, createSimpleKnownConfigurationOptions());
166 | 	assertConfigurationIs(result, {
167 | 		allowJsExtension: false,
168 | 		baseUrl: 'myBaseUrl/',
169 | 		catchError: true,
170 | 		ignoreDuplicateModules: ['a'],
171 | 		isBuild: false,
172 | 		paths: { 'a': 'b' },
173 | 		config: { 'd': {}, 'e': {} },
174 | 		urlArgs: 'myUrlArgs',
175 | 		cspNonce: '',
176 | 		preferScriptTags: false,
177 | 		recordStats: false
178 | 	});
179 | 
180 | 	// Change defined module configs
181 | 	result = loader.ConfigurationOptionsUtil.mergeConfigurationOptions({
182 | 		config: { 'd': { 'a': 'a' } }
183 | 	}, createSimpleKnownConfigurationOptions());
184 | 	assertConfigurationIs(result, {
185 | 		allowJsExtension: false,
186 | 		baseUrl: 'myBaseUrl/',
187 | 		catchError: true,
188 | 		ignoreDuplicateModules: ['a'],
189 | 		isBuild: false,
190 | 		paths: { 'a': 'b' },
191 | 		config: { 'd': { 'a': 'a' } },
192 | 		urlArgs: 'myUrlArgs',
193 | 		cspNonce: '',
194 | 		preferScriptTags: false,
195 | 		recordStats: false
196 | 	});
197 | });
198 | 
199 | QUnit.test('Overwriting unknown configuration options', () => {
200 | 	var result = loader.ConfigurationOptionsUtil.mergeConfigurationOptions();
201 | 	assertConfigurationIs(result, {
202 | 		allowJsExtension: false,
203 | 		baseUrl: '',
204 | 		catchError: false,
205 | 		ignoreDuplicateModules: [],
206 | 		isBuild: false,
207 | 		paths: {},
208 | 		config: {},
209 | 		urlArgs: '',
210 | 		cspNonce: '',
211 | 		preferScriptTags: false,
212 | 		recordStats: false
213 | 	});
214 | 
215 | 	// Adding unknown key
216 | 	result = loader.ConfigurationOptionsUtil.mergeConfigurationOptions(<any>{
217 | 		unknownKey1: 'value1'
218 | 	}, result);
219 | 	assertConfigurationIs(result, <any>{
220 | 		allowJsExtension: false,
221 | 		baseUrl: '',
222 | 		catchError: false,
223 | 		ignoreDuplicateModules: [],
224 | 		isBuild: false,
225 | 		paths: {},
226 | 		config: {},
227 | 		urlArgs: '',
228 | 		cspNonce: '',
229 | 		preferScriptTags: false,
230 | 		recordStats: false,
231 | 		unknownKey1: 'value1'
232 | 	});
233 | 
234 | 	// Adding another unknown key
235 | 	result = loader.ConfigurationOptionsUtil.mergeConfigurationOptions(<any>{
236 | 		unknownKey2: 'value2'
237 | 	}, result);
238 | 	assertConfigurationIs(result, <any>{
239 | 		allowJsExtension: false,
240 | 		baseUrl: '',
241 | 		catchError: false,
242 | 		ignoreDuplicateModules: [],
243 | 		isBuild: false,
244 | 		paths: {},
245 | 		config: {},
246 | 		urlArgs: '',
247 | 		cspNonce: '',
248 | 		preferScriptTags: false,
249 | 		recordStats: false,
250 | 		unknownKey1: 'value1',
251 | 		unknownKey2: 'value2'
252 | 	});
253 | 
254 | 	// Overwriting unknown key
255 | 	result = loader.ConfigurationOptionsUtil.mergeConfigurationOptions(<any>{
256 | 		unknownKey2: 'new-value2'
257 | 	}, result);
258 | 	assertConfigurationIs(result, <any>{
259 | 		allowJsExtension: false,
260 | 		baseUrl: '',
261 | 		catchError: false,
262 | 		ignoreDuplicateModules: [],
263 | 		isBuild: false,
264 | 		paths: {},
265 | 		config: {},
266 | 		urlArgs: '',
267 | 		cspNonce: '',
268 | 		preferScriptTags: false,
269 | 		recordStats: false,
270 | 		unknownKey1: 'value1',
271 | 		unknownKey2: 'new-value2'
272 | 	});
273 | });
274 | 
275 | QUnit.module('Configuration');
276 | 
277 | QUnit.test('moduleIdToPath', () => {
278 | 	var config = new loader.Configuration(new loader.Environment(), {
279 | 		baseUrl: 'prefix',
280 | 		urlArgs: 'suffix',
281 | 		paths: {
282 | 			'a': 'newa',
283 | 			'knockout': 'http://ajax.aspnetcdn.com/ajax/knockout/knockout-2.2.1.js',
284 | 			'editor': '/src/editor'
285 | 		}
286 | 	});
287 | 
288 | 	// baseUrl is applied
289 | 	QUnit.equal(config.moduleIdToPaths('b/c/d'), 'prefix/b/c/d.js?suffix');
290 | 
291 | 	// paths rules are applied
292 | 	QUnit.equal(config.moduleIdToPaths('a'), 'prefix/newa.js?suffix');
293 | 	QUnit.equal(config.moduleIdToPaths('a/b/c/d'), 'prefix/newa/b/c/d.js?suffix');
294 | 
295 | 	// paths rules check if value is an absolute path
296 | 	QUnit.equal(config.moduleIdToPaths('knockout'), 'http://ajax.aspnetcdn.com/ajax/knockout/knockout-2.2.1.js?suffix');
297 | 
298 | 	// modules ending in .js skip baseUrl + paths rules
299 | 	QUnit.equal(config.moduleIdToPaths('b/c/d.js'), 'b/c/d.js?suffix');
300 | 	QUnit.equal(config.moduleIdToPaths('a/b/c/d.js'), 'a/b/c/d.js?suffix');
301 | 	QUnit.equal(config.moduleIdToPaths('a.js'), 'a.js?suffix');
302 | 
303 | 	// modules redirected to / still get .js appended
304 | 	QUnit.equal(config.moduleIdToPaths('editor/x'), '/src/editor/x.js?suffix');
305 | 
306 | 	// modules starting with / skip baseUrl + paths rules
307 | 	QUnit.equal(config.moduleIdToPaths('/b/c/d'), '/b/c/d.js?suffix');
308 | 	QUnit.equal(config.moduleIdToPaths('/a/b/c/d'), '/a/b/c/d.js?suffix');
309 | 	QUnit.equal(config.moduleIdToPaths('/a'), '/a.js?suffix');
310 | 
311 | 	// modules starting with http:// or https:// skip baseUrl + paths rules
312 | 	QUnit.equal(config.moduleIdToPaths('file:///c:/a/b/c'), 'file:///c:/a/b/c.js?suffix');
313 | 	QUnit.equal(config.moduleIdToPaths('http://b/c/d'), 'http://b/c/d.js?suffix');
314 | 	QUnit.equal(config.moduleIdToPaths('http://a/b/c/d'), 'http://a/b/c/d.js?suffix');
315 | 	QUnit.equal(config.moduleIdToPaths('http://a'), 'http://a.js?suffix');
316 | 	QUnit.equal(config.moduleIdToPaths('https://b/c/d'), 'https://b/c/d.js?suffix');
317 | 	QUnit.equal(config.moduleIdToPaths('https://a/b/c/d'), 'https://a/b/c/d.js?suffix');
318 | 	QUnit.equal(config.moduleIdToPaths('https://a'), 'https://a.js?suffix');
319 | });
320 | 
321 | QUnit.test('moduleIdToPath with allowJsExtension', () => {
322 | 	var config = new loader.Configuration(new loader.Environment(), {
323 | 		allowJsExtension: true,
324 | 		baseUrl: 'prefix',
325 | 		urlArgs: 'suffix',
326 | 		paths: {
327 | 			'a': 'newa',
328 | 			'knockout': 'http://ajax.aspnetcdn.com/ajax/knockout/knockout-2.2.1.js',
329 | 			'knockout.js': 'http://ajax.aspnetcdn.com/ajax/knockout/knockout-2.2.1.js',
330 | 			'editor': '/src/editor'
331 | 		}
332 | 	});
333 | 
334 | 	// baseUrl is applied
335 | 	QUnit.equal(config.moduleIdToPaths('b/c/d'), 'prefix/b/c/d.js?suffix');
336 | 	QUnit.equal(config.moduleIdToPaths('b/c/d.js'), 'prefix/b/c/d.js?suffix');
337 | 
338 | 	// paths rules are applied
339 | 	QUnit.equal(config.moduleIdToPaths('a'), 'prefix/newa.js?suffix');
340 | 	QUnit.equal(config.moduleIdToPaths('a.js'), 'prefix/newa.js?suffix');
341 | 	QUnit.equal(config.moduleIdToPaths('a/b/c/d'), 'prefix/newa/b/c/d.js?suffix');
342 | 	QUnit.equal(config.moduleIdToPaths('a/b/c/d.js'), 'prefix/newa/b/c/d.js?suffix');
343 | 
344 | 	// paths rules check if value is an absolute path
345 | 	QUnit.equal(config.moduleIdToPaths('knockout'), 'http://ajax.aspnetcdn.com/ajax/knockout/knockout-2.2.1.js?suffix');
346 | 	QUnit.equal(config.moduleIdToPaths('knockout.js'), 'http://ajax.aspnetcdn.com/ajax/knockout/knockout-2.2.1.js?suffix');
347 | 
348 | 	// modules redirected to / still get .js appended
349 | 	QUnit.equal(config.moduleIdToPaths('editor/x'), '/src/editor/x.js?suffix');
350 | 	QUnit.equal(config.moduleIdToPaths('editor/x.js'), '/src/editor/x.js?suffix');
351 | 
352 | 	// modules starting with / skip baseUrl + paths rules
353 | 	QUnit.equal(config.moduleIdToPaths('/b/c/d'), '/b/c/d.js?suffix');
354 | 	QUnit.equal(config.moduleIdToPaths('/b/c/d.js'), '/b/c/d.js?suffix');
355 | 	QUnit.equal(config.moduleIdToPaths('/a/b/c/d'), '/a/b/c/d.js?suffix');
356 | 	QUnit.equal(config.moduleIdToPaths('/a/b/c/d.js'), '/a/b/c/d.js?suffix');
357 | 	QUnit.equal(config.moduleIdToPaths('/a'), '/a.js?suffix');
358 | 	QUnit.equal(config.moduleIdToPaths('/a.js'), '/a.js?suffix');
359 | 
360 | 	// modules starting with http:// or https:// skip baseUrl + paths rules
361 | 	QUnit.equal(config.moduleIdToPaths('file:///c:/a/b/c'), 'file:///c:/a/b/c.js?suffix');
362 | 	QUnit.equal(config.moduleIdToPaths('file:///c:/a/b/c.js'), 'file:///c:/a/b/c.js?suffix');
363 | 	QUnit.equal(config.moduleIdToPaths('http://b/c/d'), 'http://b/c/d.js?suffix');
364 | 	QUnit.equal(config.moduleIdToPaths('http://b/c/d.js'), 'http://b/c/d.js?suffix');
365 | 	QUnit.equal(config.moduleIdToPaths('http://a/b/c/d'), 'http://a/b/c/d.js?suffix');
366 | 	QUnit.equal(config.moduleIdToPaths('http://a/b/c/d.js'), 'http://a/b/c/d.js?suffix');
367 | 	QUnit.equal(config.moduleIdToPaths('http://a'), 'http://a.js?suffix');
368 | 	QUnit.equal(config.moduleIdToPaths('http://a.js'), 'http://a.js?suffix');
369 | 	QUnit.equal(config.moduleIdToPaths('https://b/c/d'), 'https://b/c/d.js?suffix');
370 | 	QUnit.equal(config.moduleIdToPaths('https://b/c/d.js'), 'https://b/c/d.js?suffix');
371 | 	QUnit.equal(config.moduleIdToPaths('https://a/b/c/d'), 'https://a/b/c/d.js?suffix');
372 | 	QUnit.equal(config.moduleIdToPaths('https://a/b/c/d.js'), 'https://a/b/c/d.js?suffix');
373 | 	QUnit.equal(config.moduleIdToPaths('https://a'), 'https://a.js?suffix');
374 | 	QUnit.equal(config.moduleIdToPaths('https://a.js'), 'https://a.js?suffix');
375 | });
376 | 
377 | QUnit.test('requireToUrl', () => {
378 | 	var config = new loader.Configuration(new loader.Environment(), {
379 | 		baseUrl: 'prefix',
380 | 		urlArgs: 'suffix',
381 | 		paths: {
382 | 			'a': 'newa'
383 | 		}
384 | 	});
385 | 
386 | 	// baseUrl is applied
387 | 	QUnit.equal(config.requireToUrl('b/c/d'), 'prefix/b/c/d?suffix');
388 | 	QUnit.equal(config.requireToUrl('../a/b/c/d'), 'prefix/../a/b/c/d?suffix');
389 | 
390 | 	// paths rules are applied
391 | 	QUnit.equal(config.requireToUrl('a'), 'prefix/newa?suffix');
392 | 	QUnit.equal(config.requireToUrl('a/b/c/d'), 'prefix/newa/b/c/d?suffix');
393 | 
394 | 	// urls ending in .js get no special treatment
395 | 	QUnit.equal(config.requireToUrl('b/c/d.js'), 'prefix/b/c/d.js?suffix');
396 | 	QUnit.equal(config.requireToUrl('a/b/c/d.js'), 'prefix/newa/b/c/d.js?suffix');
397 | 	QUnit.equal(config.requireToUrl('a.js'), 'prefix/newa.js?suffix');
398 | 
399 | 	// requireToUrl does not append .js
400 | 	QUnit.equal(config.requireToUrl('b/c/d.png'), 'prefix/b/c/d.png?suffix');
401 | 	QUnit.equal(config.requireToUrl('a/b/c/d.png'), 'prefix/newa/b/c/d.png?suffix');
402 | 	QUnit.equal(config.requireToUrl('a.png'), 'prefix/newa.png?suffix');
403 | 
404 | 	// urls starting with / skip baseUrl + paths rules
405 | 	QUnit.equal(config.requireToUrl('/b/c/d'), '/b/c/d?suffix');
406 | 	QUnit.equal(config.requireToUrl('/a/b/c/d'), '/a/b/c/d?suffix');
407 | 	QUnit.equal(config.requireToUrl('/a'), '/a?suffix');
408 | 
409 | 	// urls starting with http:// or https:// skip baseUrl + paths rules
410 | 	QUnit.equal(config.requireToUrl('http://b/c/d'), 'http://b/c/d?suffix');
411 | 	QUnit.equal(config.requireToUrl('http://a/b/c/d'), 'http://a/b/c/d?suffix');
412 | 	QUnit.equal(config.requireToUrl('http://a'), 'http://a?suffix');
413 | 	QUnit.equal(config.requireToUrl('https://b/c/d'), 'https://b/c/d?suffix');
414 | 	QUnit.equal(config.requireToUrl('https://a/b/c/d'), 'https://a/b/c/d?suffix');
415 | 	QUnit.equal(config.requireToUrl('https://a'), 'https://a?suffix');
416 | });
417 | 
418 | QUnit.test('ignoreDuplicateModules', () => {
419 | 	var config = new loader.Configuration(new loader.Environment(), {
420 | 		ignoreDuplicateModules: ['a1', 'a2', 'a/b/c']
421 | 	});
422 | 
423 | 	QUnit.equal(config.isDuplicateMessageIgnoredFor('a1'), true);
424 | 	QUnit.equal(config.isDuplicateMessageIgnoredFor('a2'), true);
425 | 	QUnit.equal(config.isDuplicateMessageIgnoredFor('a/b/c'), true);
426 | 	QUnit.equal(config.isDuplicateMessageIgnoredFor('a'), false);
427 | });
428 | 
429 | QUnit.module('ModuleIdResolver');
430 | 
431 | QUnit.test('resolveModule', () => {
432 | 	var resolver = new loader.ModuleIdResolver('a/b/c/d');
433 | 
434 | 	// normal modules
435 | 	QUnit.equal(resolver.resolveModule('e/f/g'), 'e/f/g');
436 | 	QUnit.equal(resolver.resolveModule('e/f/../f/g'), 'e/f/../f/g');
437 | 
438 | 	// normal modules ending in .js
439 | 	QUnit.equal(resolver.resolveModule('e/f/g.js'), 'e/f/g.js');
440 | 
441 | 	// relative modules
442 | 	QUnit.equal(resolver.resolveModule('./e/f/g'), 'a/b/c/e/f/g');
443 | 	QUnit.equal(resolver.resolveModule('../e/f/g'), 'a/b/e/f/g');
444 | 	QUnit.equal(resolver.resolveModule('../../e/f/g'), 'a/e/f/g');
445 | 	QUnit.equal(resolver.resolveModule('../../../e/f/g'), 'e/f/g');
446 | 	QUnit.equal(resolver.resolveModule('../../../../e/f/g'), '../e/f/g');
447 | 	QUnit.equal(resolver.resolveModule('../b/../c/d'), 'a/b/c/d');
448 | 
449 | 	// relative modules ending in .js
450 | 	QUnit.equal(resolver.resolveModule('./e/f/g.js'), 'a/b/c/e/f/g.js');
451 | 	QUnit.equal(resolver.resolveModule('../e/f/g.js'), 'a/b/e/f/g.js');
452 | 	QUnit.equal(resolver.resolveModule('../../e/f/g.js'), 'a/e/f/g.js');
453 | 	QUnit.equal(resolver.resolveModule('../../../e/f/g.js'), 'e/f/g.js');
454 | 	QUnit.equal(resolver.resolveModule('../../../../e/f/g.js'), '../e/f/g.js');
455 | 
456 | 	// modules starting with /
457 | 	QUnit.equal(resolver.resolveModule('/b/c/d'), '/b/c/d');
458 | 	QUnit.equal(resolver.resolveModule('/a'), '/a');
459 | 	QUnit.equal(resolver.resolveModule('/a/b/c/d.js'), '/a/b/c/d.js');
460 | 	QUnit.equal(resolver.resolveModule('/../a/b/c'), '/../a/b/c');
461 | 
462 | 	// modules starting with http:// or https://
463 | 	QUnit.equal(resolver.resolveModule('http://b/c/d'), 'http://b/c/d');
464 | 	QUnit.equal(resolver.resolveModule('http://a'), 'http://a');
465 | 	QUnit.equal(resolver.resolveModule('http://a/b/c/d.js'), 'http://a/b/c/d.js');
466 | 	QUnit.equal(resolver.resolveModule('https://b/c/d'), 'https://b/c/d');
467 | 	QUnit.equal(resolver.resolveModule('https://a'), 'https://a');
468 | 	QUnit.equal(resolver.resolveModule('https://a/b/c/d.js'), 'https://a/b/c/d.js');
469 | 
470 | 	// modules starting with file://
471 | 	QUnit.equal(resolver.resolveModule('file://b/c/d'), 'file://b/c/d');
472 | 	QUnit.equal(resolver.resolveModule('file://a'), 'file://a');
473 | 	QUnit.equal(resolver.resolveModule('file://a/b/c/d.js'), 'file://a/b/c/d.js');
474 | 
475 | 	QUnit.equal(loader.ModuleIdResolver._normalizeModuleId('./a'), 'a');
476 | 	QUnit.equal(loader.ModuleIdResolver._normalizeModuleId('./././a'), 'a');
477 | 	QUnit.equal(loader.ModuleIdResolver._normalizeModuleId('a/b/c/d/../../../../../e/f/g/h'), '../e/f/g/h');
478 | 	QUnit.equal(loader.ModuleIdResolver._normalizeModuleId('file:///c:/a/b/c/d/e.f.g/h/./j'), 'file:///c:/a/b/c/d/e.f.g/h/j');
479 | 	QUnit.equal(loader.ModuleIdResolver._normalizeModuleId('../../ab/../a'), '../../a');
480 | });
481 | 
482 | QUnit.module('ModuleManager');
483 | 
484 | QUnit.test('Loading 3 simple modules', () => {
485 | 	QUnit.expect(3);
486 | 
487 | 	var scriptLoader: loader.IScriptLoader = {
488 | 		load: (moduleManager: AMDLoader.IModuleManager, scriptPath: string, loadCallback: () => void, errorCallback: (err: any) => void) => {
489 | 			if (scriptPath === 'a1.js') {
490 | 				mm.enqueueDefineAnonymousModule([], 'a1');
491 | 				loadCallback();
492 | 			} else if (scriptPath === 'a2.js') {
493 | 				mm.defineModule('a2', [], 'a2', null, null);
494 | 				loadCallback();
495 | 			} else {
496 | 				QUnit.ok(false);
497 | 			}
498 | 		},
499 | 	};
500 | 
501 | 	var mm = new loader.ModuleManager(new loader.Environment(), scriptLoader, null, null);
502 | 
503 | 	mm.defineModule('a', ['a1', 'a2'], (a1: string, a2: string) => {
504 | 		QUnit.equal(a1, 'a1');
505 | 		QUnit.equal(a2, 'a2');
506 | 		return 'a';
507 | 	}, null, null);
508 | 
509 | 	QUnit.equal(mm.synchronousRequire('a'), 'a');
510 | });
511 | 
512 | QUnit.test('Loading a plugin dependency', () => {
513 | 	QUnit.expect(5);
514 | 
515 | 	var scriptLoader: loader.IScriptLoader = {
516 | 		load: (moduleManager: AMDLoader.IModuleManager, scriptPath: string, loadCallback: () => void, errorCallback: (err: any) => void) => {
517 | 			if (scriptPath === 'plugin.js') {
518 | 				mm.enqueueDefineAnonymousModule([], {
519 | 					normalize: (pluginParam: string, normalize: (moduleId: string) => string) => {
520 | 						return normalize(pluginParam);
521 | 					},
522 | 					load: (pluginParam: string, parentRequire: loader.IRelativeRequire, loadCallback: loader.IPluginLoadCallback, options: loader.IConfigurationOptions) => {
523 | 						parentRequire([pluginParam], (v: any) => loadCallback(v));
524 | 					}
525 | 				});
526 | 				loadCallback();
527 | 			} else if (scriptPath === 'a/b/d.js') {
528 | 				mm.enqueueDefineAnonymousModule([], 'r');
529 | 				loadCallback();
530 | 			} else {
531 | 				QUnit.ok(false, 'Unexpected scriptPath: ' + scriptPath);
532 | 			}
533 | 		},
534 | 	};
535 | 
536 | 	var mm = new loader.ModuleManager(new loader.Environment(), scriptLoader, null, null);
537 | 
538 | 	mm.defineModule('a/b/c', ['../../plugin!./d', 'require'], (r: any, req: any) => {
539 | 		QUnit.equal(r, 'r');
540 | 		QUnit.equal(req.toUrl('./d.txt'), 'a/b/d.txt');
541 | 		return 'a/b/c';
542 | 	}, null, null);
543 | 
544 | 	QUnit.equal(mm.synchronousRequire('a/b/c'), 'a/b/c');
545 | 
546 | 	mm.defineModule('a2', ['./plugin!a/b/d'], (r: any) => {
547 | 		QUnit.equal(r, 'r');
548 | 		return 'a2';
549 | 	}, null, null);
550 | 
551 | 	QUnit.equal(mm.synchronousRequire('a2'), 'a2');
552 | });
553 | 
554 | QUnit.test('Loading a dependency cycle', () => {
555 | 	QUnit.expect(6);
556 | 
557 | 	var scriptLoader: loader.IScriptLoader = {
558 | 		load: (moduleManager: AMDLoader.IModuleManager, scriptPath: string, loadCallback: () => void, errorCallback: (err: any) => void) => {
559 | 			if (scriptPath === 'b.js') {
560 | 				mm.enqueueDefineAnonymousModule(['c'], (c: any) => {
561 | 					// This is how the cycle is broken. One of the modules receives undefined as the argument value
562 | 					QUnit.equal(c, 'c');
563 | 					return 'b';
564 | 				});
565 | 				loadCallback();
566 | 			} else if (scriptPath === 'c.js') {
567 | 				mm.enqueueDefineAnonymousModule(['a'], (a: any) => {
568 | 					// This is how the cycle is broken. One of the modules receives undefined as the argument value
569 | 					QUnit.deepEqual(a, {});
570 | 					// QUnit.ok(typeof a === 'undefined');
571 | 					return 'c';
572 | 				});
573 | 				loadCallback();
574 | 			} else {
575 | 				QUnit.ok(false, 'Unexpected scriptPath: ' + scriptPath);
576 | 			}
577 | 		},
578 | 	};
579 | 
580 | 	var mm = new loader.ModuleManager(new loader.Environment(), scriptLoader, null, null);
581 | 	mm.defineModule('a', ['b'], (b: any) => {
582 | 		QUnit.equal(b, 'b');
583 | 		return 'a';
584 | 	}, null, null);
585 | 
586 | 	QUnit.equal(mm.synchronousRequire('a'), 'a');
587 | 	QUnit.equal(mm.synchronousRequire('b'), 'b');
588 | 	QUnit.equal(mm.synchronousRequire('c'), 'c');
589 | });
590 | 
591 | QUnit.test('Using a local error handler immediate script loading failure', () => {
592 | 	QUnit.expect(1);
593 | 
594 | 	// a -> b and b fails to load
595 | 
596 | 	var scriptLoader: loader.IScriptLoader = {
597 | 		load: (moduleManager: AMDLoader.IModuleManager, scriptPath: string, loadCallback: () => void, errorCallback: (err: any) => void) => {
598 | 			if (scriptPath === 'b.js') {
599 | 				errorCallback('b.js not found');
600 | 			} else {
601 | 				QUnit.ok(false, 'Unexpected scriptPath: ' + scriptPath);
602 | 			}
603 | 		},
604 | 	};
605 | 
606 | 	var mm = new loader.ModuleManager(new loader.Environment(), scriptLoader, null, null);
607 | 	mm.defineModule('a', ['b'], (b: any) => {
608 | 		QUnit.equal(b, 'b');
609 | 		return 'a';
610 | 	}, (err) => {
611 | 		QUnit.equal(err.message, 'b.js not found');
612 | 	}, null);
613 | 
614 | });
615 | 
616 | QUnit.test('Using a local error handler secondary script loading failure', () => {
617 | 	QUnit.expect(1);
618 | 
619 | 	// a -> b -> c and c fails to load
620 | 
621 | 	var scriptLoader: loader.IScriptLoader = {
622 | 		load: (moduleManager: AMDLoader.IModuleManager, scriptPath: string, loadCallback: () => void, errorCallback: (err: any) => void) => {
623 | 			if (scriptPath === 'b.js') {
624 | 				mm.enqueueDefineAnonymousModule(['c'], (c: any) => {
625 | 					QUnit.equal(c, 'c');
626 | 					return 'b';
627 | 				});
628 | 				loadCallback();
629 | 			} else if (scriptPath === 'c.js') {
630 | 				errorCallback('c.js not found');
631 | 			} else {
632 | 				QUnit.ok(false, 'Unexpected scriptPath: ' + scriptPath);
633 | 			}
634 | 		},
635 | 	};
636 | 
637 | 	var mm = new loader.ModuleManager(new loader.Environment(), scriptLoader, null, null);
638 | 	mm.defineModule('a', ['b'], (b: any) => {
639 | 		QUnit.ok(false);
640 | 	}, (err) => {
641 | 		QUnit.equal(err.message, 'c.js not found');
642 | 	}, null);
643 | });
644 | 
645 | QUnit.test('RelativeRequire error handler', () => {
646 | 	QUnit.expect(1);
647 | 
648 | 	const dne = 'Does not exist';
649 | 	var scriptLoader: loader.IScriptLoader = {
650 | 		load: (moduleManager: AMDLoader.IModuleManager, scriptPath: string, loadCallback: () => void, errorCallback: (err: any) => void) => {
651 | 			errorCallback(new Error(dne));
652 | 		},
653 | 	};
654 | 
655 | 	var mm = new loader.ModuleManager(new loader.Environment(), scriptLoader, null, null);
656 | 	mm.defineModule('a/b/d', ['require'], (relativeRequire) => {
657 | 		relativeRequire(['doesnotexist'], undefined, (err: Error) => {
658 | 			QUnit.deepEqual(err.message, dne);
659 | 		});
660 | 		return 'a/b/d';
661 | 	}, null, null);
662 | });
663 | 
664 | QUnit.module('FallBack Tests');
665 | 
666 | QUnit.test('No path config', () => {
667 | 	QUnit.expect(1);
668 | 
669 | 	var scriptLoader: loader.IScriptLoader = {
670 | 		load: (moduleManager: AMDLoader.IModuleManager, scriptPath: string, loadCallback: () => void, errorCallback: (err: any) => void) => {
671 | 			if (scriptPath === 'a.js') {
672 | 				errorCallback('a.js not found');
673 | 			} else {
674 | 				QUnit.ok(false, 'Unexpected scriptPath: ' + scriptPath);
675 | 			}
676 | 		},
677 | 	};
678 | 
679 | 	var mm = new loader.ModuleManager(new loader.Environment(), scriptLoader, null, null);
680 | 	mm.defineModule('first', ['a'], () => {
681 | 		QUnit.ok(false, 'a should not be found');
682 | 	}, (err) => {
683 | 		QUnit.ok(true, 'a should not be found');
684 | 	}, null);
685 | });
686 | 
687 | QUnit.test('With path config', () => {
688 | 	QUnit.expect(1);
689 | 
690 | 	var scriptLoader: loader.IScriptLoader = {
691 | 		load: (moduleManager: AMDLoader.IModuleManager, scriptPath: string, loadCallback: () => void, errorCallback: (err: any) => void) => {
692 | 			if (scriptPath === 'alocation.js') {
693 | 				errorCallback('alocation.js not found');
694 | 			} else {
695 | 				QUnit.ok(false, 'Unexpected scriptPath: ' + scriptPath);
696 | 			}
697 | 		},
698 | 	};
699 | 
700 | 	var mm = new loader.ModuleManager(new loader.Environment(), scriptLoader, null, null);
701 | 	mm.configure({
702 | 		paths: {
703 | 			a: 'alocation.js'
704 | 		}
705 | 	}, false);
706 | 	mm.defineModule('first', ['a'], () => {
707 | 		QUnit.ok(false, 'a should not be found');
708 | 	}, (err) => {
709 | 		QUnit.ok(true, 'a should not be found');
710 | 	}, null);
711 | });
712 | 
713 | QUnit.test('With one fallback', () => {
714 | 	QUnit.expect(1);
715 | 
716 | 	var scriptLoader: loader.IScriptLoader = {
717 | 		load: (moduleManager: AMDLoader.IModuleManager, scriptPath: string, loadCallback: () => void, errorCallback: (err: any) => void) => {
718 | 			if (scriptPath === 'alocation.js') {
719 | 				errorCallback('alocation.js not found');
720 | 			} else if (scriptPath === 'afallback.js') {
721 | 				mm.enqueueDefineAnonymousModule([], () => {
722 | 					return 'a';
723 | 				});
724 | 				loadCallback();
725 | 			} else {
726 | 				QUnit.ok(false, 'Unexpected scriptPath: ' + scriptPath);
727 | 			}
728 | 		},
729 | 	};
730 | 
731 | 	var mm = new loader.ModuleManager(new loader.Environment(), scriptLoader, null, null);
732 | 
733 | 	mm.configure({
734 | 		paths: {
735 | 			a: ['alocation.js', 'afallback.js']
736 | 		}
737 | 	}, false);
738 | 
739 | 	mm.defineModule('first', ['a'], () => {
740 | 		QUnit.ok(true, 'a was found');
741 | 	}, (err) => {
742 | 		QUnit.ok(false, 'a was not found');
743 | 	}, null);
744 | });
745 | 
746 | QUnit.test('With two fallbacks', () => {
747 | 	QUnit.expect(1);
748 | 
749 | 	var scriptLoader: loader.IScriptLoader = {
750 | 		load: (moduleManager: AMDLoader.IModuleManager, scriptPath: string, loadCallback: () => void, errorCallback: (err: any) => void) => {
751 | 			if (scriptPath === 'alocation.js') {
752 | 				errorCallback('alocation.js not found');
753 | 			} else if (scriptPath === 'afallback.js') {
754 | 				errorCallback('afallback.js not found');
755 | 			} else if (scriptPath === 'anotherfallback.js') {
756 | 				mm.enqueueDefineAnonymousModule([], () => {
757 | 					return 'a';
758 | 				});
759 | 				loadCallback();
760 | 			} else {
761 | 				QUnit.ok(false, 'Unexpected scriptPath: ' + scriptPath);
762 | 			}
763 | 		},
764 | 	};
765 | 
766 | 	var mm = new loader.ModuleManager(new loader.Environment(), scriptLoader, null, null);
767 | 
768 | 	mm.configure({
769 | 		paths: {
770 | 			a: ['alocation.js', 'afallback.js', 'anotherfallback.js']
771 | 		}
772 | 	}, false);
773 | 
774 | 	mm.defineModule('first', ['a'], () => {
775 | 		QUnit.ok(true, 'a was found');
776 | 	}, (err) => {
777 | 		QUnit.ok(false, 'a was not found');
778 | 	}, null);
779 | });
780 | 
781 | QUnit.module('Bugs');
782 | 
783 | QUnit.test('Bug #11710: [loader] Loader can enter a stale-mate when the last dependency to resolve is a (missing) plugin dependency', () => {
784 | 	QUnit.expect(2);
785 | 
786 | 	// A script loader that captures the load request for 'plugin.js'
787 | 	var scriptLoader: loader.IScriptLoader = {
788 | 		load: (moduleManager: AMDLoader.IModuleManager, scriptPath: string, loadCallback: () => void, errorCallback: (err: any) => void) => {
789 | 			QUnit.ok(false, 'Unexpected scriptPath: ' + scriptPath);
790 | 		},
791 | 	};
792 | 
793 | 	var mm = new loader.ModuleManager(new loader.Environment(), scriptLoader, null, null);
794 | 
795 | 	// Define the resolved plugin value
796 | 	mm.defineModule('plugin!pluginParam', [], () => {
797 | 		return {
798 | 			value: 5
799 | 		};
800 | 	}, (err) => {
801 | 		QUnit.ok(false);
802 | 	}, null);
803 | 
804 | 	// Ask for the plugin
805 | 	mm.defineModule('a', ['plugin!pluginParam'], (b: any) => {
806 | 		QUnit.equal(b.value, 5);
807 | 		return {
808 | 			value: b.value * 2
809 | 		};
810 | 	}, (err) => {
811 | 		QUnit.ok(false);
812 | 	}, null);
813 | 
814 | 	// Depend on a module that asks for the plugin
815 | 	mm.defineModule('b', ['a'], (a: any) => {
816 | 		QUnit.equal(a.value, 10);
817 | 	}, (err) => {
818 | 		QUnit.ok(false);
819 | 	}, null);
820 | });
821 | 
822 | QUnit.test('Bug #12024: [loader] Should not append .js to URLs containing query string', () => {
823 | 	var config = new loader.Configuration(new loader.Environment(), {
824 | 		baseUrl: 'prefix',
825 | 		paths: {
826 | 			'searchBoxJss': 'http://services.social.microsoft.com/search/Widgets/SearchBox.jss?boxid=HeaderSearchTextBox&btnid=HeaderSearchButton&brand=Msdn&loc=en-us&Refinement=198,234&focusOnInit=false&iroot=vscom&emptyWatermark=true&searchButtonTooltip=Search here'
827 | 		}
828 | 	});
829 | 
830 | 	// No .js is appended
831 | 	QUnit.equal(config.moduleIdToPaths('searchBoxJss'), 'http://services.social.microsoft.com/search/Widgets/SearchBox.jss?boxid=HeaderSearchTextBox&btnid=HeaderSearchButton&brand=Msdn&loc=en-us&Refinement=198,234&focusOnInit=false&iroot=vscom&emptyWatermark=true&searchButtonTooltip=Search here');
832 | });
833 | 
834 | QUnit.test('Bug #12020: [loader] relative (synchronous) require does not normalize plugin argument that follows "!"', () => {
835 | 	QUnit.expect(3);
836 | 
837 | 	var scriptLoader: loader.IScriptLoader = {
838 | 		load: (moduleManager: AMDLoader.IModuleManager, scriptPath: string, loadCallback: () => void, errorCallback: (err: any) => void) => {
839 | 			QUnit.ok(false, 'Unexpected scriptPath: ' + scriptPath);
840 | 		},
841 | 	};
842 | 
843 | 	var mm = new loader.ModuleManager(new loader.Environment(), scriptLoader, null, null);
844 | 
845 | 	mm.defineModule('plugin!a/b/c', [], () => {
846 | 		QUnit.ok(true);
847 | 		return 'plugin!a/b/c';
848 | 	}, null, null);
849 | 
850 | 	mm.defineModule('a/b/d', ['require'], (relativeRequire) => {
851 | 		QUnit.ok(true);
852 | 		QUnit.equal(relativeRequire('plugin!./c'), 'plugin!a/b/c');
853 | 		return 'a/b/d';
854 | 	}, null, null);
855 | });
856 | 
857 | QUnit.test('Utilities.fileUriToFilePath', () => {
858 | 	var test = (isWindows: boolean, input: string, expected: string) => {
859 | 		QUnit.equal(loader.Utilities.fileUriToFilePath(isWindows, input), expected, 'Result for ' + input);
860 | 	};
861 | 
862 | 	test(true, 'file:///c:/alex.txt', 'c:/alex.txt');
863 | 	test(true, 'file://monacotools/isi.txt', '//monacotools/isi.txt');
864 | 	test(true, 'file://monacotools1/certificates/SSL/', '//monacotools1/certificates/SSL/');
865 | 
866 | 	test(false, 'file:///c:/alex.txt', '/c:/alex.txt');
867 | 	test(false, 'file://monacotools/isi.txt', 'monacotools/isi.txt');
868 | 	test(false, 'file://monacotools1/certificates/SSL/', 'monacotools1/certificates/SSL/');
869 | });
870 | 
871 | QUnit.test('Utilities.containsQueryString', () => {
872 | 	var test = (input: string, expected: boolean) => {
873 | 		QUnit.equal(loader.Utilities.containsQueryString(input), expected, 'Result for ' + input);
874 | 	};
875 | 	test('http://www.microsoft.com/something?q=123&r=345#bangbang', true);
876 | 	test('http://www.microsoft.com/something#bangbang', false);
877 | 	test('http://www.microsoft.com/something#bangbang?asd=3', false);
878 | 	test('http://www.microsoft.com/something#?asd=3', false);
879 | });
880 | 


--------------------------------------------------------------------------------
/tests/ms-specific/tests/fallback_double_fallback/_reporter.js:
--------------------------------------------------------------------------------
 1 | // _reporter.js
 2 | (function() {
 3 | 	var factory = function () {
 4 | 		var exports = {};
 5 | 
 6 | 		exports.print = function () {
 7 | 			// global print
 8 | 			if (typeof amdJSPrint !== "undefined") {
 9 | 				amdJSPrint.apply(undefined, arguments);
10 | 			}
11 | 			else {
12 | 				var stdout = require("system").stdout;
13 | 				stdout.print.apply(stdout, arguments);
14 | 			}
15 | 		};
16 | 
17 | 		exports.assert = function (guard, message) {
18 | 			if (guard) {
19 | 				exports.print("PASS " + message, "pass");
20 | 			} else {
21 | 				exports.print("FAIL " + message, "fail");
22 | 			}
23 | 		};
24 | 
25 | 		return exports;
26 | 	};
27 | 
28 | 	// define this module
29 | 	define("_reporter", [], factory);
30 | 
31 | })();


--------------------------------------------------------------------------------
/tests/ms-specific/tests/fallback_double_fallback/_test.js:
--------------------------------------------------------------------------------
 1 | 
 2 | config({
 3 | 	baseUrl: '.',
 4 | 	paths:{'doublefoo':['doublefoo0', 'doublefoo1', 'doublefoo2']}
 5 | });
 6 | go( ["_reporter", "doublefoo"],
 7 | 	function (amdJS, doublefoo) {
 8 | 		amdJS.assert("doublefoo2" === doublefoo.name, "fallback_double_fallback: doublefoo.name:"+ doublefoo.name);
 9 | 		amdJS.print("DONE", "done");
10 | 	});
11 | 


--------------------------------------------------------------------------------
/tests/ms-specific/tests/fallback_double_fallback/doublefoo2.js:
--------------------------------------------------------------------------------
1 | define(function () {
2 | 	return {
3 | 		name: 'doublefoo2'
4 | 	};
5 | });


--------------------------------------------------------------------------------
/tests/ms-specific/tests/fallback_original_works/_reporter.js:
--------------------------------------------------------------------------------
 1 | // _reporter.js
 2 | (function() {
 3 | 	var factory = function () {
 4 | 		var exports = {};
 5 | 
 6 | 		exports.print = function () {
 7 | 			// global print
 8 | 			if (typeof amdJSPrint !== "undefined") {
 9 | 				amdJSPrint.apply(undefined, arguments);
10 | 			}
11 | 			else {
12 | 				var stdout = require("system").stdout;
13 | 				stdout.print.apply(stdout, arguments);
14 | 			}
15 | 		};
16 | 
17 | 		exports.assert = function (guard, message) {
18 | 			if (guard) {
19 | 				exports.print("PASS " + message, "pass");
20 | 			} else {
21 | 				exports.print("FAIL " + message, "fail");
22 | 			}
23 | 		};
24 | 
25 | 		return exports;
26 | 	};
27 | 
28 | 	// define this module
29 | 	define("_reporter", [], factory);
30 | 
31 | })();


--------------------------------------------------------------------------------
/tests/ms-specific/tests/fallback_original_works/_test.js:
--------------------------------------------------------------------------------
 1 | 
 2 | config({
 3 | 	baseUrl: '.',
 4 | 	paths:{'a':['a', 'alt']}
 5 | });
 6 | go( ["_reporter", "a"],
 7 | 	function (amdJS, a) {
 8 | 		amdJS.assert("a" === a.name, "fallback_original_works: a.name:"+ a.name);
 9 | 		amdJS.print("DONE", "done");
10 | 	});
11 | 


--------------------------------------------------------------------------------
/tests/ms-specific/tests/fallback_original_works/a.js:
--------------------------------------------------------------------------------
1 | define(function () {
2 | 	return {
3 | 		name: 'a'
4 | 	};
5 | });


--------------------------------------------------------------------------------
/tests/ms-specific/tests/fallback_original_works/alt.js:
--------------------------------------------------------------------------------
1 | define(function () {
2 | 	return {
3 | 		name: 'alt'
4 | 	};
5 | });


--------------------------------------------------------------------------------
/tests/ms-specific/tests/fallback_single_fallback/_reporter.js:
--------------------------------------------------------------------------------
 1 | // _reporter.js
 2 | (function() {
 3 | 	var factory = function () {
 4 | 		var exports = {};
 5 | 
 6 | 		exports.print = function () {
 7 | 			// global print
 8 | 			if (typeof amdJSPrint !== "undefined") {
 9 | 				amdJSPrint.apply(undefined, arguments);
10 | 			}
11 | 			else {
12 | 				var stdout = require("system").stdout;
13 | 				stdout.print.apply(stdout, arguments);
14 | 			}
15 | 		};
16 | 
17 | 		exports.assert = function (guard, message) {
18 | 			if (guard) {
19 | 				exports.print("PASS " + message, "pass");
20 | 			} else {
21 | 				exports.print("FAIL " + message, "fail");
22 | 			}
23 | 		};
24 | 
25 | 		return exports;
26 | 	};
27 | 
28 | 	// define this module
29 | 	define("_reporter", [], factory);
30 | 
31 | })();


--------------------------------------------------------------------------------
/tests/ms-specific/tests/fallback_single_fallback/_test.js:
--------------------------------------------------------------------------------
 1 | 
 2 | config({
 3 | 	baseUrl: '.',
 4 | 	paths:{'a':['foonothere', 'foofallback']}
 5 | });
 6 | go( ["_reporter", "a"],
 7 | 	function (amdJS, foonothere) {
 8 | 		amdJS.assert("foofallback" === foonothere.name, "fallback_single_fallback: foonothere.name:" + foonothere.name);
 9 | 		amdJS.print("DONE", "done");
10 | 	});
11 | 


--------------------------------------------------------------------------------
/tests/ms-specific/tests/fallback_single_fallback/foofallback.js:
--------------------------------------------------------------------------------
1 | define(function () {
2 | 	return {
3 | 		name: 'foofallback'
4 | 	};
5 | });


--------------------------------------------------------------------------------
/tests/node-specific/_control.js:
--------------------------------------------------------------------------------
 1 | 
 2 | var continuation = function() {
 3 | 	console.error('Control misconfigured, needs continuation function');
 4 | };
 5 | 
 6 | exports.setContinuation = function(_continuation) {
 7 | 	continuation = _continuation;
 8 | }
 9 | 
10 | exports.ok = function() {
11 | 	continuation(null);
12 | }
13 | 
14 | exports.err = function(err) {
15 | 	continuation(err ? err : new Error('Unknown error'));
16 | }


--------------------------------------------------------------------------------
/tests/node-specific/_loader.js:
--------------------------------------------------------------------------------
1 | module.exports = require('../../src/loader');


--------------------------------------------------------------------------------
/tests/node-specific/exporting-function/_test.js:
--------------------------------------------------------------------------------
 1 | var loader = require('../_loader');
 2 | var control = require('../_control');
 3 | 
 4 | loader.config({
 5 | 	nodeRequire: require,
 6 | 	baseUrl: __dirname
 7 | });
 8 | 
 9 | loader(['a'], function(a) {
10 | 	if (typeof a === 'function') {
11 | 		control.ok();
12 | 	} else {
13 | 		control.err('Unexpected dependencies values');
14 | 	}
15 | }, function(err) {
16 | 	control.err(err);
17 | });


--------------------------------------------------------------------------------
/tests/node-specific/exporting-function/a.js:
--------------------------------------------------------------------------------
1 | 
2 | 'use strict';
3 | 
4 | define(function() {
5 | 	return function() {
6 | 		console.log('hello world');
7 | 	};
8 | });
9 | 


--------------------------------------------------------------------------------
/tests/node-specific/has-dirname/_test.js:
--------------------------------------------------------------------------------
 1 | var loader = require('../_loader');
 2 | var control = require('../_control');
 3 | 
 4 | loader.config({
 5 | 	nodeRequire: require,
 6 | 	baseUrl: __dirname
 7 | });
 8 | 
 9 | loader(['./a'], function(a) {
10 | 	if (typeof a.dirname !== 'string' || typeof a.filename !== 'string') {
11 | 		control.err('Expected strings...');
12 | 		return;
13 | 	}
14 | 	if (a.dirname.length === 0 || a.filename.length === 0) {
15 | 		control.err('Expected non empty strings...');
16 | 		return;
17 | 	}
18 | 
19 | 	if (a.filename.lastIndexOf('a.js') !== a.filename.length - 4) {
20 | 		control.err('Expected filename ending in a.js');
21 | 		return;
22 | 	}
23 | 
24 | 	if (a.filename.indexOf(a.dirname) !== 0) {
25 | 		control.err('Expected dirname to be prefix of filename');
26 | 		return;
27 | 	}
28 | 
29 | 	control.ok();
30 | 
31 | }, function(err) {
32 | 	control.err(err);
33 | });


--------------------------------------------------------------------------------
/tests/node-specific/has-dirname/a.js:
--------------------------------------------------------------------------------
 1 | 
 2 | 'use strict';
 3 | 
 4 | define(function() {
 5 | 	return {
 6 | 		dirname: __dirname,
 7 | 		filename: __filename
 8 | 	};
 9 | });
10 | 


--------------------------------------------------------------------------------
/tests/node-specific/simple/_test.js:
--------------------------------------------------------------------------------
 1 | var loader = require('../_loader');
 2 | var control = require('../_control');
 3 | 
 4 | loader.config({
 5 | 	nodeRequire: require,
 6 | 	baseUrl: __dirname
 7 | });
 8 | 
 9 | loader(['./folder/foo', 'fs'], function(foo, fs) {
10 | 	if (foo.foo === 5 && typeof fs.readFileSync === 'function') {
11 | 		control.ok();
12 | 	} else {
13 | 		control.err('Unexpected dependencies values');
14 | 	}
15 | }, function(err) {
16 | 	control.err(err);
17 | });


--------------------------------------------------------------------------------
/tests/node-specific/simple/folder/foo.js:
--------------------------------------------------------------------------------
1 | define(function() {
2 | 	return {
3 | 		foo: 5
4 | 	};
5 | })


--------------------------------------------------------------------------------
/tests/node-specific/throwing-amd/_test.js:
--------------------------------------------------------------------------------
 1 | var loader = require('../_loader');
 2 | var control = require('../_control');
 3 | 
 4 | loader.config({
 5 | 	nodeRequire: require,
 6 | 	baseUrl: __dirname,
 7 | 	catchError: true,
 8 | 	onError: function (err) {
 9 | 		control.ok();
10 | 	}
11 | });
12 | 
13 | loader(['./a'], function(a) { /* onError above will continue the test runner */ });


--------------------------------------------------------------------------------
/tests/node-specific/throwing-amd/a.js:
--------------------------------------------------------------------------------
1 | define(function() {
2 | 	throw new Error('I throw!');
3 | });


--------------------------------------------------------------------------------
/tests/node-specific/what-is-this/_test.js:
--------------------------------------------------------------------------------
 1 | var loader = require('../_loader');
 2 | var control = require('../_control');
 3 | 
 4 | loader.config({
 5 | 	nodeRequire: require,
 6 | 	baseUrl: __dirname
 7 | });
 8 | 
 9 | loader(['./a'], function(a) {
10 | 	if (a.foo === 5) {
11 | 		control.ok();
12 | 	} else {
13 | 		control.err('Unexpected dependencies values');
14 | 	}
15 | }, function(err) {
16 | 	control.err(err);
17 | });


--------------------------------------------------------------------------------
/tests/node-specific/what-is-this/a.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | 
3 | var __extends = this.__extends || function (d, b) {
4 | 	for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
5 | 	function __() { this.constructor = d; }
6 | 	__.prototype = b.prototype;
7 | 	d.prototype = new __();
8 | };
9 | define({ foo: 5 });


--------------------------------------------------------------------------------
/tests/node-specific/z-cached-data-create/_test.js:
--------------------------------------------------------------------------------
 1 | var fs = require('fs');
 2 | var path = require('path');
 3 | var loader = require('../_loader');
 4 | var control = require('../_control');
 5 | 
 6 | var nodeCachedDataDir = path.join(__dirname, 'cache-dir');
 7 | 
 8 | loader.config({
 9 | 	nodeRequire: require,
10 | 	baseUrl: __dirname,
11 | 	nodeCachedData: {
12 | 		path: nodeCachedDataDir,
13 | 		seed: 'foo',
14 | 		writeDelay: 0
15 | 	}
16 | });
17 | 
18 | 
19 | loader(['a'], function (a) {
20 | 
21 | 	setTimeout(() => {
22 | 
23 | 		const files = fs.readdirSync(nodeCachedDataDir).filter(p => /\.code$/.test(p));
24 | 		if (files.length === 1) {
25 | 			control.ok();
26 | 		} else {
27 | 			control.err('Unexpected .code-files' + files.join(', '));
28 | 		}
29 | 		for (const f of files) {
30 | 			fs.unlinkSync(path.join(nodeCachedDataDir, f));
31 | 		}
32 | 
33 | 	}, 100);
34 | });
35 | 


--------------------------------------------------------------------------------
/tests/node-specific/z-cached-data-create/a.js:
--------------------------------------------------------------------------------
1 | 
2 | 'use strict';
3 | 
4 | define(function() {
5 | 	return function() {
6 | 		console.log('hello world');
7 | 	};
8 | });
9 | 


--------------------------------------------------------------------------------
/tests/node-specific/z-cached-data-create/cache-dir/.gitkeep:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/microsoft/vscode-loader/a4681f93aec3ae3170baf5e0148132c8b777e208/tests/node-specific/z-cached-data-create/cache-dir/.gitkeep


--------------------------------------------------------------------------------
/tests/qunit/qunit.css:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * QUnit v1.12.0 - A JavaScript Unit Testing Framework
  3 |  *
  4 |  * http://qunitjs.com
  5 |  *
  6 |  * Copyright 2012 jQuery Foundation and other contributors
  7 |  * Released under the MIT license.
  8 |  * http://jquery.org/license
  9 |  */
 10 | 
 11 | /** Font Family and Sizes */
 12 | 
 13 | #qunit-tests, #qunit-header, #qunit-banner, #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult {
 14 | 	font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial, sans-serif;
 15 | }
 16 | 
 17 | #qunit-testrunner-toolbar, #qunit-userAgent, #qunit-testresult, #qunit-tests li { font-size: small; }
 18 | #qunit-tests { font-size: smaller; }
 19 | 
 20 | 
 21 | /** Resets */
 22 | 
 23 | #qunit-tests, #qunit-header, #qunit-banner, #qunit-userAgent, #qunit-testresult, #qunit-modulefilter {
 24 | 	margin: 0;
 25 | 	padding: 0;
 26 | }
 27 | 
 28 | 
 29 | /** Header */
 30 | 
 31 | #qunit-header {
 32 | 	padding: 0.5em 0 0.5em 1em;
 33 | 
 34 | 	color: #8699a4;
 35 | 	background-color: #0d3349;
 36 | 
 37 | 	font-size: 1.5em;
 38 | 	line-height: 1em;
 39 | 	font-weight: normal;
 40 | 
 41 | 	border-radius: 5px 5px 0 0;
 42 | 	-moz-border-radius: 5px 5px 0 0;
 43 | 	-webkit-border-top-right-radius: 5px;
 44 | 	-webkit-border-top-left-radius: 5px;
 45 | }
 46 | 
 47 | #qunit-header a {
 48 | 	text-decoration: none;
 49 | 	color: #c2ccd1;
 50 | }
 51 | 
 52 | #qunit-header a:hover,
 53 | #qunit-header a:focus {
 54 | 	color: #fff;
 55 | }
 56 | 
 57 | #qunit-testrunner-toolbar label {
 58 | 	display: inline-block;
 59 | 	padding: 0 .5em 0 .1em;
 60 | }
 61 | 
 62 | #qunit-banner {
 63 | 	height: 5px;
 64 | }
 65 | 
 66 | #qunit-testrunner-toolbar {
 67 | 	padding: 0.5em 0 0.5em 2em;
 68 | 	color: #5E740B;
 69 | 	background-color: #eee;
 70 | 	overflow: hidden;
 71 | }
 72 | 
 73 | #qunit-userAgent {
 74 | 	padding: 0.5em 0 0.5em 2.5em;
 75 | 	background-color: #2b81af;
 76 | 	color: #fff;
 77 | 	text-shadow: rgba(0, 0, 0, 0.5) 2px 2px 1px;
 78 | }
 79 | 
 80 | #qunit-modulefilter-container {
 81 | 	float: right;
 82 | }
 83 | 
 84 | /** Tests: Pass/Fail */
 85 | 
 86 | #qunit-tests {
 87 | 	list-style-position: inside;
 88 | }
 89 | 
 90 | #qunit-tests li {
 91 | 	padding: 0.4em 0.5em 0.4em 2.5em;
 92 | 	border-bottom: 1px solid #fff;
 93 | 	list-style-position: inside;
 94 | }
 95 | 
 96 | #qunit-tests.hidepass li.pass, #qunit-tests.hidepass li.running  {
 97 | 	display: none;
 98 | }
 99 | 
100 | #qunit-tests li strong {
101 | 	cursor: pointer;
102 | }
103 | 
104 | #qunit-tests li a {
105 | 	padding: 0.5em;
106 | 	color: #c2ccd1;
107 | 	text-decoration: none;
108 | }
109 | #qunit-tests li a:hover,
110 | #qunit-tests li a:focus {
111 | 	color: #000;
112 | }
113 | 
114 | #qunit-tests li .runtime {
115 | 	float: right;
116 | 	font-size: smaller;
117 | }
118 | 
119 | .qunit-assert-list {
120 | 	margin-top: 0.5em;
121 | 	padding: 0.5em;
122 | 
123 | 	background-color: #fff;
124 | 
125 | 	border-radius: 5px;
126 | 	-moz-border-radius: 5px;
127 | 	-webkit-border-radius: 5px;
128 | }
129 | 
130 | .qunit-collapsed {
131 | 	display: none;
132 | }
133 | 
134 | #qunit-tests table {
135 | 	border-collapse: collapse;
136 | 	margin-top: .2em;
137 | }
138 | 
139 | #qunit-tests th {
140 | 	text-align: right;
141 | 	vertical-align: top;
142 | 	padding: 0 .5em 0 0;
143 | }
144 | 
145 | #qunit-tests td {
146 | 	vertical-align: top;
147 | }
148 | 
149 | #qunit-tests pre {
150 | 	margin: 0;
151 | 	white-space: pre-wrap;
152 | 	word-wrap: break-word;
153 | }
154 | 
155 | #qunit-tests del {
156 | 	background-color: #e0f2be;
157 | 	color: #374e0c;
158 | 	text-decoration: none;
159 | }
160 | 
161 | #qunit-tests ins {
162 | 	background-color: #ffcaca;
163 | 	color: #500;
164 | 	text-decoration: none;
165 | }
166 | 
167 | /*** Test Counts */
168 | 
169 | #qunit-tests b.counts                       { color: black; }
170 | #qunit-tests b.passed                       { color: #5E740B; }
171 | #qunit-tests b.failed                       { color: #710909; }
172 | 
173 | #qunit-tests li li {
174 | 	padding: 5px;
175 | 	background-color: #fff;
176 | 	border-bottom: none;
177 | 	list-style-position: inside;
178 | }
179 | 
180 | /*** Passing Styles */
181 | 
182 | #qunit-tests li li.pass {
183 | 	color: #3c510c;
184 | 	background-color: #fff;
185 | 	border-left: 10px solid #C6E746;
186 | }
187 | 
188 | #qunit-tests .pass                          { color: #528CE0; background-color: #D2E0E6; }
189 | #qunit-tests .pass .test-name               { color: #366097; }
190 | 
191 | #qunit-tests .pass .test-actual,
192 | #qunit-tests .pass .test-expected           { color: #999999; }
193 | 
194 | #qunit-banner.qunit-pass                    { background-color: #C6E746; }
195 | 
196 | /*** Failing Styles */
197 | 
198 | #qunit-tests li li.fail {
199 | 	color: #710909;
200 | 	background-color: #fff;
201 | 	border-left: 10px solid #EE5757;
202 | 	white-space: pre;
203 | }
204 | 
205 | #qunit-tests > li:last-child {
206 | 	border-radius: 0 0 5px 5px;
207 | 	-moz-border-radius: 0 0 5px 5px;
208 | 	-webkit-border-bottom-right-radius: 5px;
209 | 	-webkit-border-bottom-left-radius: 5px;
210 | }
211 | 
212 | #qunit-tests .fail                          { color: #000000; background-color: #EE5757; }
213 | #qunit-tests .fail .test-name,
214 | #qunit-tests .fail .module-name             { color: #000000; }
215 | 
216 | #qunit-tests .fail .test-actual             { color: #EE5757; }
217 | #qunit-tests .fail .test-expected           { color: green;   }
218 | 
219 | #qunit-banner.qunit-fail                    { background-color: #EE5757; }
220 | 
221 | 
222 | /** Result */
223 | 
224 | #qunit-testresult {
225 | 	padding: 0.5em 0.5em 0.5em 2.5em;
226 | 
227 | 	color: #2b81af;
228 | 	background-color: #D2E0E6;
229 | 
230 | 	border-bottom: 1px solid white;
231 | }
232 | #qunit-testresult .module-name {
233 | 	font-weight: bold;
234 | }
235 | 
236 | /** Fixture */
237 | 
238 | #qunit-fixture {
239 | 	position: absolute;
240 | 	top: -10000px;
241 | 	left: -10000px;
242 | 	width: 1000px;
243 | 	height: 1000px;
244 | }


--------------------------------------------------------------------------------
/tests/qunit/qunit.d.ts:
--------------------------------------------------------------------------------
  1 | // Type definitions for QUnit 1.10
  2 | // Project: http://qunitjs.com/
  3 | // Definitions by: Diullei Gomes <https://github.com/diullei>
  4 | // DefinitelyTyped: https://github.com/borisyankov/DefinitelyTyped
  5 | 
  6 | 
  7 | interface DoneCallbackObject {
  8 | 	/**
  9 | 	* The number of failed assertions
 10 | 	*/
 11 | 	failed: number;
 12 | 
 13 | 	/**
 14 | 	* The number of passed assertions
 15 | 	*/
 16 | 	passed: number;
 17 | 
 18 | 	/**
 19 | 	* The total number of assertions
 20 | 	*/
 21 | 	total: number;
 22 | 
 23 | 	/**
 24 | 	* The time in milliseconds it took tests to run from start to finish.
 25 | 	*/
 26 | 	runtime: number;
 27 | }
 28 | 
 29 | interface LogCallbackObject {
 30 | 	/**
 31 | 	* The boolean result of an assertion, true means passed, false means failed.
 32 | 	*/
 33 | 	result: boolean;
 34 | 
 35 | 	/**
 36 | 	* One side of a comparision assertion. Can be undefined when ok() is used.
 37 | 	*/
 38 | 	actual: Object;
 39 | 
 40 | 	/**
 41 | 	* One side of a comparision assertion. Can be undefined when ok() is used.
 42 | 	*/
 43 | 	expected: Object;
 44 | 
 45 | 	/**
 46 | 	* A string description provided by the assertion.
 47 | 	*/
 48 | 	message: string;
 49 | 
 50 | 	/**
 51 | 	* The associated stacktrace, either from an exception or pointing to the source
 52 | 	* of the assertion. Depends on browser support for providing stacktraces, so can be
 53 | 	* undefined.
 54 | 	*/
 55 | 	source: string;
 56 | }
 57 | 
 58 | interface ModuleStartCallbackObject {
 59 | 	/**
 60 | 	* Name of the next module to run
 61 | 	*/
 62 | 	name: string;
 63 | }
 64 | 
 65 | interface ModuleDoneCallbackObject {
 66 | 	/**
 67 | 	* Name of this module
 68 | 	*/
 69 | 	name: string;
 70 | 
 71 | 	/**
 72 | 	* The number of failed assertions
 73 | 	*/
 74 | 	failed: number;
 75 | 
 76 | 	/**
 77 | 	* The number of passed assertions
 78 | 	*/
 79 | 	passed: number;
 80 | 
 81 | 	/**
 82 | 	* The total number of assertions
 83 | 	*/
 84 | 	total: number;
 85 | }
 86 | 
 87 | interface TestDoneCallbackObject {
 88 | 	/**
 89 | 	* TName of the next test to run
 90 | 	*/
 91 | 	name: string;
 92 | 
 93 | 	/**
 94 | 	* Name of the current module
 95 | 	*/
 96 | 	module: string;
 97 | 
 98 | 	/**
 99 | 	* The number of failed assertions
100 | 	*/
101 | 	failed: number;
102 | 
103 | 	/**
104 | 	* The number of passed assertions
105 | 	*/
106 | 	passed: number;
107 | 
108 | 	/**
109 | 	* The total number of assertions
110 | 	*/
111 | 	total: number;
112 | 
113 | 	/**
114 | 	* The total runtime, including setup and teardown
115 | 	*/
116 | 	duration: number;
117 | }
118 | 
119 | interface TestStartCallbackObject {
120 | 	/**
121 | 	* Name of the next test to run
122 | 	*/
123 | 	name: string;
124 | 
125 | 	/**
126 | 	* Name of the current module
127 | 	*/
128 | 	module: string;
129 | }
130 | 
131 | interface Config {
132 | 	altertitle: boolean;
133 | 	autostart: boolean;
134 | 	current: Object;
135 | 	reorder: boolean;
136 | 	requireExpects: boolean;
137 | 	testTimeout: number;
138 | 	urlConfig: any[];
139 | 	done: any;
140 | }
141 | 
142 | interface LifecycleObject {
143 | 	/**
144 | 	* Runs before each test
145 | 	*/
146 | 	setup?: () => any;
147 | 
148 | 	/**
149 | 	* Runs after each test
150 | 	*/
151 | 	teardown?: () => any;
152 | }
153 | 
154 | interface QUnitAssert {
155 | 	/* ASSERT */
156 | 	assert: any;
157 | 	current_testEnvironment: any;
158 | 	jsDump: any;
159 | 
160 | 	/**
161 | 	* A deep recursive comparison assertion, working on primitive types, arrays, objects,
162 | 	* regular expressions, dates and functions.
163 | 	*
164 | 	* The deepEqual() assertion can be used just like equal() when comparing the value of
165 | 	* objects, such that { key: value } is equal to { key: value }. For non-scalar values,
166 | 	* identity will be disregarded by deepEqual.
167 | 	*
168 | 	* @param actual Object or Expression being tested
169 | 	* @param expected Known comparison value
170 | 	* @param message A short description of the assertion
171 | 	*/
172 | 	deepEqual(actual: any, expected: any, message?: string);
173 | 
174 | 	/**
175 | 	* A non-strict comparison assertion, roughly equivalent to JUnit assertEquals.
176 | 	*
177 | 	* The equal assertion uses the simple comparison operator (==) to compare the actual
178 | 	* and expected arguments. When they are equal, the assertion passes; otherwise, it fails.
179 | 	* When it fails, both actual and expected values are displayed in the test result,
180 | 	* in addition to a given message.
181 | 	*
182 | 	* @param actual Expression being tested
183 | 	* @param expected Known comparison value
184 | 	* @param message A short description of the assertion
185 | 	*/
186 | 	equal(actual: any, expected: any, message?: string);
187 | 
188 | 	/**
189 | 	* An inverted deep recursive comparison assertion, working on primitive types,
190 | 	* arrays, objects, regular expressions, dates and functions.
191 | 	*
192 | 	* The notDeepEqual() assertion can be used just like equal() when comparing the
193 | 	* value of objects, such that { key: value } is equal to { key: value }. For non-scalar
194 | 	* values, identity will be disregarded by notDeepEqual.
195 | 	*
196 | 	* @param actual Object or Expression being tested
197 | 	* @param expected Known comparison value
198 | 	* @param message A short description of the assertion
199 | 	*/
200 | 	notDeepEqual(actual: any, expected: any, message?: string);
201 | 
202 | 	/**
203 | 	* A non-strict comparison assertion, checking for inequality.
204 | 	*
205 | 	* The notEqual assertion uses the simple inverted comparison operator (!=) to compare
206 | 	* the actual and expected arguments. When they aren't equal, the assertion passes;
207 | 	* otherwise, it fails. When it fails, both actual and expected values are displayed
208 | 	* in the test result, in addition to a given message.
209 | 	*
210 | 	* @param actual Expression being tested
211 | 	* @param expected Known comparison value
212 | 	* @param message A short description of the assertion
213 | 	*/
214 | 	notEqual(actual: any, expected: any, message?: string);
215 | 
216 | 	notPropEqual(actual: any, expected: any, message?: string);
217 | 
218 | 	propEqual(actual: any, expected: any, message?: string);
219 | 
220 | 	/**
221 | 	* A non-strict comparison assertion, checking for inequality.
222 | 	*
223 | 	* The notStrictEqual assertion uses the strict inverted comparison operator (!==)
224 | 	* to compare the actual and expected arguments. When they aren't equal, the assertion
225 | 	* passes; otherwise, it fails. When it fails, both actual and expected values are
226 | 	* displayed in the test result, in addition to a given message.
227 | 	*
228 | 	* @param actual Expression being tested
229 | 	* @param expected Known comparison value
230 | 	* @param message A short description of the assertion
231 | 	*/
232 | 	notStrictEqual(actual: any, expected: any, message?: string);
233 | 
234 | 	/**
235 | 	* A boolean assertion, equivalent to CommonJS’s assert.ok() and JUnit’s assertTrue().
236 | 	* Passes if the first argument is truthy.
237 | 	*
238 | 	* The most basic assertion in QUnit, ok() requires just one argument. If the argument
239 | 	* evaluates to true, the assertion passes; otherwise, it fails. If a second message
240 | 	* argument is provided, it will be displayed in place of the result.
241 | 	*
242 | 	* @param state Expression being tested
243 | 	* @param message A short description of the assertion
244 | 	*/
245 | 	ok(state: any, message?: string);
246 | 
247 | 	/**
248 | 	* A strict type and value comparison assertion.
249 | 	*
250 | 	* The strictEqual() assertion provides the most rigid comparison of type and value with
251 | 	* the strict equality operator (===)
252 | 	*
253 | 	* @param actual Expression being tested
254 | 	* @param expected Known comparison value
255 | 	* @param message A short description of the assertion
256 | 	*/
257 | 	strictEqual(actual: any, expected: any, message?: string);
258 | 
259 | 	/**
260 | 	* Assertion to test if a callback throws an exception when run.
261 | 	*
262 | 	* When testing code that is expected to throw an exception based on a specific set of
263 | 	* circumstances, use throws() to catch the error object for testing and comparison.
264 | 	*
265 | 	* @param block Function to execute
266 | 	* @param expected Error Object to compare
267 | 	* @param message A short description of the assertion
268 | 	*/
269 | 	throws(block: () => any, expected: any, message?: string);
270 | 
271 | 	/**
272 | 	* @param block Function to execute
273 | 	* @param message A short description of the assertion
274 | 	*/
275 | 	throws(block: () => any, message?: string);
276 | }
277 | 
278 | interface QUnitStatic extends QUnitAssert{
279 | 	/* ASYNC CONTROL */
280 | 
281 | 	/**
282 | 	* Start running tests again after the testrunner was stopped. See stop().
283 | 	*
284 | 	* When your async test has multiple exit points, call start() for the corresponding number of stop() increments.
285 | 	*
286 | 	* @param decrement Optional argument to merge multiple start() calls into one. Use with multiple corrsponding stop() calls.
287 | 	*/
288 | 	start(decrement?: number);
289 | 
290 | 	/**
291 | 	* Stop the testrunner to wait for async tests to run. Call start() to continue.
292 | 	*
293 | 	* When your async test has multiple exit points, call stop() with the increment argument, corresponding to the number of start() calls you need.
294 | 	*
295 | 	* On Blackberry 5.0, window.stop is a native read-only function. If you deal with that browser, use QUnit.stop() instead, which will work anywhere.
296 | 	*
297 | 	* @param decrement Optional argument to merge multiple stop() calls into one. Use with multiple corrsponding start() calls.
298 | 	*/
299 | 	stop(increment? : number);
300 | 
301 | 	/* CALLBACKS */
302 | 
303 | 	/**
304 | 	* Register a callback to fire whenever the test suite begins.
305 | 	*
306 | 	* QUnit.begin() is called once before running any tests. (a better would've been QUnit.start,
307 | 	* but thats already in use elsewhere and can't be changed.)
308 | 	*
309 | 	* @param callback Callback to execute
310 | 	*/
311 | 	begin(callback: () => any);
312 | 
313 | 	/**
314 | 	* Register a callback to fire whenever the test suite ends.
315 | 	*
316 | 	* @param callback Callback to execute.
317 | 	*/
318 | 	done(callback: (details: DoneCallbackObject) => any);
319 | 
320 | 	/**
321 | 	* Register a callback to fire whenever an assertion completes.
322 | 	*
323 | 	* This is one of several callbacks QUnit provides. Its intended for integration scenarios like
324 | 	* PhantomJS or Jenkins. The properties of the details argument are listed below as options.
325 | 	*
326 | 	* @param callback Callback to execute.
327 | 	*/
328 | 	log(callback: (details: LogCallbackObject) => any);
329 | 
330 | 	/**
331 | 	* Register a callback to fire whenever a module ends.
332 | 	*
333 | 	* @param callback Callback to execute.
334 | 	*/
335 | 	moduleDone(callback: (details: ModuleDoneCallbackObject) => any);
336 | 
337 | 	/**
338 | 	* Register a callback to fire whenever a module begins.
339 | 	*
340 | 	* @param callback Callback to execute.
341 | 	*/
342 | 	moduleStart(callback: (details: ModuleStartCallbackObject) => any);
343 | 
344 | 	/**
345 | 	* Register a callback to fire whenever a test ends.
346 | 	*
347 | 	* @param callback Callback to execute.
348 | 	*/
349 | 	testDone(callback: (details: TestDoneCallbackObject) => any);
350 | 
351 | 	/**
352 | 	* Register a callback to fire whenever a test begins.
353 | 	*
354 | 	* @param callback Callback to execute.
355 | 	*/
356 | 	testStart(callback: (details: TestStartCallbackObject) => any);
357 | 
358 | 	/* CONFIGURATION */
359 | 
360 | 	/**
361 | 	* QUnit has a bunch of internal configuration defaults, some of which are
362 | 	* useful to override. Check the description for each option for details.
363 | 	*/
364 | 	config: Config;
365 | 
366 | 	/* TEST */
367 | 
368 | 	/**
369 | 	* Add an asynchronous test to run. The test must include a call to start().
370 | 	*
371 | 	* For testing asynchronous code, asyncTest will automatically stop the test runner
372 | 	* and wait for your code to call start() to continue.
373 | 	*
374 | 	* @param name Title of unit being tested
375 | 	* @param expected Number of assertions in this test
376 | 	* @param test Function to close over assertions
377 | 	*/
378 | 	asyncTest(name: string, expected: number, test: () => any);
379 | 
380 | 	/**
381 | 	* Add an asynchronous test to run. The test must include a call to start().
382 | 	*
383 | 	* For testing asynchronous code, asyncTest will automatically stop the test runner
384 | 	* and wait for your code to call start() to continue.
385 | 	*
386 | 	* @param name Title of unit being tested
387 | 	* @param test Function to close over assertions
388 | 	*/
389 | 	asyncTest(name: string, test: () => any);
390 | 
391 | 	/**
392 | 	* Specify how many assertions are expected to run within a test.
393 | 	*
394 | 	* To ensure that an explicit number of assertions are run within any test, use
395 | 	* expect( number ) to register an expected count. If the number of assertions
396 | 	* run does not match the expected count, the test will fail.
397 | 	*
398 | 	* @param amount Number of assertions in this test.
399 | 	*/
400 | 	expect(amount: number);
401 | 
402 | 	/**
403 | 	* Group related tests under a single label.
404 | 	*
405 | 	* All tests that occur after a call to module() will be grouped into that module.
406 | 	* The test names will all be preceded by the module name in the test results.
407 | 	* You can then use that module name to select tests to run.
408 | 	*
409 | 	* @param name Label for this group of tests
410 | 	* @param lifecycle Callbacks to run before and after each test
411 | 	*/
412 | 	module(name: string, lifecycle?: LifecycleObject);
413 | 
414 | 	/**
415 | 	* Add a test to run.
416 | 	*
417 | 	* When testing the most common, synchronous code, use test().
418 | 	* The assert argument to the callback contains all of QUnit's assertion methods.
419 | 	* If you are avoiding using any of QUnit's globals, you can use the assert
420 | 	* argument instead.
421 | 	*
422 | 	* @param title Title of unit being tested
423 | 	* @param expected Number of assertions in this test
424 | 	* @param test Function to close over assertions
425 | 	*/
426 | 	test(title: string, expected: number, test: (assert: QUnitAssert) => any);
427 | 
428 | 	/**
429 | 	* @param title Title of unit being tested
430 | 	* @param test Function to close over assertions
431 | 	*/
432 | 	test(title: string, test: (assert: QUnitAssert) => any);
433 | 
434 | 	/**
435 | 	* https://github.com/jquery/qunit/blob/master/qunit/qunit.js#L1568
436 | 	*/
437 | 	equiv(a: any, b: any);
438 | 
439 | 	// https://github.com/jquery/qunit/blob/master/qunit/qunit.js#L661
440 | 	raises: any;
441 | 
442 | 	/**
443 | 	* https://github.com/jquery/qunit/blob/master/qunit/qunit.js#L897
444 | 	*/
445 | 	push(result, actual, expected, message): any;
446 | 
447 | 	/**
448 | 	* https://github.com/jquery/qunit/blob/master/qunit/qunit.js#L839
449 | 	*/
450 | 	reset(): any;
451 | }
452 | 
453 | /* ASSERT */
454 | 
455 | /**
456 | * A deep recursive comparison assertion, working on primitive types, arrays, objects,
457 | * regular expressions, dates and functions.
458 | *
459 | * The deepEqual() assertion can be used just like equal() when comparing the value of
460 | * objects, such that { key: value } is equal to { key: value }. For non-scalar values,
461 | * identity will be disregarded by deepEqual.
462 | *
463 | * @param actual Object or Expression being tested
464 | * @param expected Known comparison value
465 | * @param message A short description of the assertion
466 | */
467 | declare function deepEqual(actual: any, expected: any, message?: string);
468 | 
469 | /**
470 | * A non-strict comparison assertion, roughly equivalent to JUnit assertEquals.
471 | *
472 | * The equal assertion uses the simple comparison operator (==) to compare the actual
473 | * and expected arguments. When they are equal, the assertion passes; otherwise, it fails.
474 | * When it fails, both actual and expected values are displayed in the test result,
475 | * in addition to a given message.
476 | *
477 | * @param actual Expression being tested
478 | * @param expected Known comparison value
479 | * @param message A short description of the assertion
480 | */
481 | declare function equal(actual: any, expected: any, message?: string);
482 | 
483 | /**
484 | * An inverted deep recursive comparison assertion, working on primitive types,
485 | * arrays, objects, regular expressions, dates and functions.
486 | *
487 | * The notDeepEqual() assertion can be used just like equal() when comparing the
488 | * value of objects, such that { key: value } is equal to { key: value }. For non-scalar
489 | * values, identity will be disregarded by notDeepEqual.
490 | *
491 | * @param actual Object or Expression being tested
492 | * @param expected Known comparison value
493 | * @param message A short description of the assertion
494 | */
495 | declare function notDeepEqual(actual: any, expected: any, message?: string);
496 | 
497 | /**
498 | * A non-strict comparison assertion, checking for inequality.
499 | *
500 | * The notEqual assertion uses the simple inverted comparison operator (!=) to compare
501 | * the actual and expected arguments. When they aren't equal, the assertion passes;
502 | * otherwise, it fails. When it fails, both actual and expected values are displayed
503 | * in the test result, in addition to a given message.
504 | *
505 | * @param actual Expression being tested
506 | * @param expected Known comparison value
507 | * @param message A short description of the assertion
508 | */
509 | declare function notEqual(actual: any, expected: any, message?: string);
510 | 
511 | /**
512 | * A non-strict comparison assertion, checking for inequality.
513 | *
514 | * The notStrictEqual assertion uses the strict inverted comparison operator (!==)
515 | * to compare the actual and expected arguments. When they aren't equal, the assertion
516 | * passes; otherwise, it fails. When it fails, both actual and expected values are
517 | * displayed in the test result, in addition to a given message.
518 | *
519 | * @param actual Expression being tested
520 | * @param expected Known comparison value
521 | * @param message A short description of the assertion
522 | */
523 | declare function notStrictEqual(actual: any, expected: any, message?: string);
524 | 
525 | /**
526 | * A boolean assertion, equivalent to CommonJS’s assert.ok() and JUnit’s assertTrue().
527 | * Passes if the first argument is truthy.
528 | *
529 | * The most basic assertion in QUnit, ok() requires just one argument. If the argument
530 | * evaluates to true, the assertion passes; otherwise, it fails. If a second message
531 | * argument is provided, it will be displayed in place of the result.
532 | *
533 | * @param state Expression being tested
534 | * @param message A short description of the assertion
535 | */
536 | declare function ok(state: any, message?: string);
537 | 
538 | /**
539 | * A strict type and value comparison assertion.
540 | *
541 | * The strictEqual() assertion provides the most rigid comparison of type and value with
542 | * the strict equality operator (===)
543 | *
544 | * @param actual Expression being tested
545 | * @param expected Known comparison value
546 | * @param message A short description of the assertion
547 | */
548 | declare function strictEqual(actual: any, expected: any, message?: string);
549 | 
550 | /**
551 | * Assertion to test if a callback throws an exception when run.
552 | *
553 | * When testing code that is expected to throw an exception based on a specific set of
554 | * circumstances, use throws() to catch the error object for testing and comparison.
555 | *
556 | * @param block Function to execute
557 | * @param expected Error Object to compare
558 | * @param message A short description of the assertion
559 | */
560 | declare function throws(block: () => any, expected: any, message?: string);
561 | 
562 | /**
563 | * @param block Function to execute
564 | * @param message A short description of the assertion
565 | */
566 | declare function throws(block: () => any, message?: string);
567 | 
568 | /* ASYNC CONTROL */
569 | 
570 | /**
571 | * Start running tests again after the testrunner was stopped. See stop().
572 | *
573 | * When your async test has multiple exit points, call start() for the corresponding number of stop() increments.
574 | *
575 | * @param decrement Optional argument to merge multiple start() calls into one. Use with multiple corrsponding stop() calls.
576 | */
577 | declare function start(decrement?: number);
578 | 
579 | /**
580 | * Stop the testrunner to wait for async tests to run. Call start() to continue.
581 | *
582 | * When your async test has multiple exit points, call stop() with the increment argument, corresponding to the number of start() calls you need.
583 | *
584 | * On Blackberry 5.0, window.stop is a native read-only function. If you deal with that browser, use QUnit.stop() instead, which will work anywhere.
585 | *
586 | * @param decrement Optional argument to merge multiple stop() calls into one. Use with multiple corrsponding start() calls.
587 | */
588 | declare function stop(increment? : number);
589 | 
590 | /* CALLBACKS */
591 | 
592 | /**
593 | * Register a callback to fire whenever the test suite begins.
594 | *
595 | * QUnit.begin() is called once before running any tests. (a better would've been QUnit.start,
596 | * but thats already in use elsewhere and can't be changed.)
597 | *
598 | * @param callback Callback to execute
599 | */
600 | declare function begin(callback: () => any);
601 | 
602 | /**
603 | * Register a callback to fire whenever the test suite ends.
604 | *
605 | * @param callback Callback to execute.
606 | */
607 | declare function done(callback: (details: DoneCallbackObject) => any);
608 | 
609 | /**
610 | * Register a callback to fire whenever an assertion completes.
611 | *
612 | * This is one of several callbacks QUnit provides. Its intended for integration scenarios like
613 | * PhantomJS or Jenkins. The properties of the details argument are listed below as options.
614 | *
615 | * @param callback Callback to execute.
616 | */
617 | declare function log(callback: (details: LogCallbackObject) => any);
618 | 
619 | /**
620 | * Register a callback to fire whenever a module ends.
621 | *
622 | * @param callback Callback to execute.
623 | */
624 | declare function moduleDone(callback: (details: ModuleDoneCallbackObject) => any);
625 | 
626 | /**
627 | * Register a callback to fire whenever a module begins.
628 | *
629 | * @param callback Callback to execute.
630 | */
631 | declare function moduleStart(callback: (name: string) => any);
632 | 
633 | /**
634 | * Register a callback to fire whenever a test ends.
635 | *
636 | * @param callback Callback to execute.
637 | */
638 | declare function testDone(callback: (details: TestDoneCallbackObject) => any);
639 | 
640 | /**
641 | * Register a callback to fire whenever a test begins.
642 | *
643 | * @param callback Callback to execute.
644 | */
645 | declare function testStart(callback: (details: TestStartCallbackObject) => any);
646 | 
647 | /* TEST */
648 | 
649 | /**
650 | * Add an asynchronous test to run. The test must include a call to start().
651 | *
652 | * For testing asynchronous code, asyncTest will automatically stop the test runner
653 | * and wait for your code to call start() to continue.
654 | *
655 | * @param name Title of unit being tested
656 | * @param expected Number of assertions in this test
657 | * @param test Function to close over assertions
658 | */
659 | declare function asyncTest(name: string, expected?: any, test?: () => any);
660 | 
661 | /**
662 | * Add an asynchronous test to run. The test must include a call to start().
663 | *
664 | * For testing asynchronous code, asyncTest will automatically stop the test runner
665 | * and wait for your code to call start() to continue.
666 | *
667 | * @param name Title of unit being tested
668 | * @param test Function to close over assertions
669 | */
670 | declare function asyncTest(name: string, test: () => any);
671 | 
672 | /**
673 | * Specify how many assertions are expected to run within a test.
674 | *
675 | * To ensure that an explicit number of assertions are run within any test, use
676 | * expect( number ) to register an expected count. If the number of assertions
677 | * run does not match the expected count, the test will fail.
678 | *
679 | * @param amount Number of assertions in this test.
680 | */
681 | declare function expect(amount: number);
682 | 
683 | // ** conflict with TypeScript module keyword. Must be used on QUnit namespace
684 | //declare var module: (name: string, lifecycle?: LifecycleObject) => any;
685 | 
686 | /**
687 | * Add a test to run.
688 | *
689 | * When testing the most common, synchronous code, use test().
690 | * The assert argument to the callback contains all of QUnit's assertion methods.
691 | * If you are avoiding using any of QUnit's globals, you can use the assert
692 | * argument instead.
693 | *
694 | * @param title Title of unit being tested
695 | * @param expected Number of assertions in this test
696 | * @param test Function to close over assertions
697 | */
698 | declare function test(title: string, expected: number, test: (assert?: QUnitAssert) => any);
699 | 
700 | /**
701 | * @param title Title of unit being tested
702 | * @param test Function to close over assertions
703 | */
704 | declare function test(title: string, test: (assert?: QUnitAssert) => any);
705 | 
706 | declare function notPropEqual(actual: any, expected: any, message?: string);
707 | 
708 | declare function propEqual(actual: any, expected: any, message?: string);
709 | 
710 | // https://github.com/jquery/qunit/blob/master/qunit/qunit.js#L1568
711 | declare function equiv(a: any, b: any);
712 | 
713 | // https://github.com/jquery/qunit/blob/master/qunit/qunit.js#L661
714 | declare var raises: any;
715 | 
716 | /* QUNIT */
717 | declare var QUnit: QUnitStatic;


--------------------------------------------------------------------------------
/tests/run-tests.htm:
--------------------------------------------------------------------------------
  1 | <!DOCTYPE html>
  2 | <html>
  3 | 	<head>
  4 | 		<meta charset="utf-8">
  5 | 		<title>AMD Loader Tests</title>
  6 | 		<link rel="stylesheet" href="qunit/qunit.css">
  7 | 	</head>
  8 | 	<body>
  9 | 		<!--<a href="http://127.0.0.1:9777/api/files/AMDLoader/tests/run-tests.htm">Normal</a>
 10 | 		<a href="http://127.0.0.1:9777/api/test/instrument/AMDLoader/tests/run-tests.htm">Coverage</a> -->
 11 | <br/>For amdjs-tests, remember to run:
 12 | <pre>
 13 | git submodule init
 14 | git submodule update
 15 | </pre>
 16 | To add integration tests, edit tests/run-tests.htm (amdjsTests array)
 17 | 		<div id="qunit"></div>
 18 | 		<div id="qunit-fixture"></div>
 19 | 		<script src="qunit/qunit.js"></script>
 20 | 		<script>
 21 | QUnit.config.autostart = false;
 22 | 
 23 | var enableCC = window.location.href.indexOf('/test/instrument/') !== -1;
 24 | var verificationTokenName = '__RequestVerificationToken';
 25 | 
 26 | function getCookie(key) {
 27 | 	if (!key) {
 28 | 		return null;
 29 | 	}
 30 | 	var cookies = document.cookie.split(';');
 31 | 	var cookie = '';
 32 | 	for (cookie in cookies) {
 33 | 		var values = cookies[cookie].split('=');
 34 | 		if (values[0].trim() === key) {
 35 | 			return values[1];
 36 | 		}
 37 | 	}
 38 | 	return null;
 39 | }
 40 | 
 41 | function whenFinishedWithAMDJSTESTS() {
 42 | 
 43 | 	if (enableCC) {
 44 | 		var req = new XMLHttpRequest();
 45 | 		var match = window.location.pathname.match('/api/test/instrument/([^/]+?)/');
 46 | 		var workspace = 'monaco';
 47 | 		if(match && match.length === 2) {
 48 | 			workspace = match[1];
 49 | 		}
 50 | 
 51 | 		req.open("POST", "/api/test/coverage/" + workspace);
 52 | 		req.setRequestHeader('Content-Type', 'application/json');
 53 | 		req.setRequestHeader(verificationTokenName, getCookie(verificationTokenName));
 54 | 		req.send(JSON.stringify(window.__$$cov));
 55 | 	}
 56 | }
 57 | 
 58 | QUnit.done = function() {
 59 | 	QUnit.done = function() { };
 60 | 	startAMDJSTESTS();
 61 | }
 62 | 
 63 | QUnit.start();
 64 | 
 65 | 		</script>
 66 | 		<script src="../src/loader.js"></script>
 67 | 
 68 | 		<script src="loader.test.js"></script>
 69 | 
 70 | <script>
 71 | // amdjs-tests
 72 | function startAMDJSTESTS() {
 73 | 	var amdjsTests = [
 74 | 		// { path: 'ms-specific/tests/', name:'tfs_scenario' },
 75 | 		// { path: 'ms-specific/tests/', name: 'bundles_config' },
 76 | 		{ path: 'ms-specific/tests/', name: 'fallback_original_works' },
 77 | 		{ path: 'ms-specific/tests/', name: 'fallback_single_fallback' },
 78 | 		{ path: 'ms-specific/tests/', name: 'fallback_double_fallback' },
 79 | 
 80 | 		{ path: 'amdjs-tests/tests/', name:'anon_circular' },
 81 | 		{ path: 'amdjs-tests/tests/', name:'anon_relative' },
 82 | 		{ path: 'amdjs-tests/tests/', name:'anon_simple' },
 83 | 		{ path: 'amdjs-tests/tests/', name:'basic_circular' },
 84 | 		{ path: 'amdjs-tests/tests/', name:'basic_define' },
 85 | 		{ path: 'amdjs-tests/tests/', name:'basic_empty_deps' },
 86 | 		{ path: 'amdjs-tests/tests/', name:'basic_no_deps' },
 87 | 		{ path: 'amdjs-tests/tests/', name:'basic_require' },
 88 | 		{ path: 'amdjs-tests/tests/', name:'basic_simple' },
 89 | 		// { path: 'amdjs-tests/tests/', name:'cjs_define' }, // this uses commonJS
 90 | 		// { path: 'amdjs-tests/tests/', name:'cjs_named' }, // this uses commonJS
 91 | 		// { path: 'amdjs-tests/tests/', name:'config_map' }, // this uses map
 92 | 		// { path: 'amdjs-tests/tests/', name:'config_map_star' }, // this uses map
 93 | 		// { path: 'amdjs-tests/tests/', name:'config_map_star_adapter' }, // this uses map
 94 | 		// { path: 'amdjs-tests/tests/', name:'config_module' },
 95 | 		// { path: 'amdjs-tests/tests/', name:'config_packages' },
 96 | 		{ path: 'amdjs-tests/tests/', name:'config_paths' },
 97 | 		{ path: 'amdjs-tests/tests/', name:'config_paths_relative' },
 98 | 		// { path: 'amdjs-tests/tests/', name:'config_shim' },
 99 | 		{ path: 'amdjs-tests/tests/', name:'plugin_double' },
100 | 		// { path: 'amdjs-tests/tests/', name:'plugin_dynamic' },
101 | 		// { path: 'amdjs-tests/tests/', name:'plugin_dynamic_string' }, // this uses commonJS
102 | 		// { path: 'amdjs-tests/tests/', name:'plugin_fromtext' }, // this would imply adding an eval() in the loader
103 | 		// { path: 'amdjs-tests/tests/', name:'plugin_normalize' } // this uses commonJS
104 | 	];
105 | 	var currentTestIndex = -1, currentTest = null, currentTestTimeout = null;
106 | 
107 | 	// Bridge for amdjs tests to QUnit & our loader
108 | 	window.go = function () {
109 | 		var newArgs = [].splice.call(arguments, 0);
110 | 		var fn = newArgs[newArgs.length - 1];
111 | 
112 | 		// pause qunit test execution until the dependencies are resolved
113 | 		QUnit.stop();
114 | 		newArgs[newArgs.length - 1] = function () {
115 | 			fn.apply(undefined, arguments);
116 | 			QUnit.start();
117 | 		};
118 | 
119 | 		define.apply(window, newArgs);
120 | 	};
121 | 
122 | 	window.amdJSPrint = function (message, type) {
123 | 		if (type === 'info') {
124 | 			return;
125 | 		}
126 | 		if (type === 'done') {
127 | 			console.log('>>>>>>>>>>>>');
128 | 			setTimeout(runOneMoreTest, 5);
129 | 			return;
130 | 		}
131 | 		QUnit.test(message, function() {
132 | 			QUnit.ok(type === 'pass', message);
133 | 		});
134 | 	};
135 | 
136 | 	window.config = require;
137 | 
138 | 	// HACK(1) to the loader to get the tests to run as if they were running independently out of their folder
139 | 	var originalValidateConfigurationOptions = AMDLoader.ConfigurationOptionsUtil.validateConfigurationOptions;
140 | 	AMDLoader.ConfigurationOptionsUtil.validateConfigurationOptions = function(isWebWorker, options) {
141 | 		var r = originalValidateConfigurationOptions(isWebWorker, options);
142 | 		if (currentTest && r.baseUrl.indexOf(currentTest.path) === -1) {
143 | 			r.baseUrl = currentTest.path + currentTest.name + '/' + r.baseUrl;
144 | 		}
145 | 		return r;
146 | 	};
147 | 
148 | 	function runOneMoreTest() {
149 | 		clearTimeout(currentTestTimeout);
150 | 
151 | 		currentTestIndex++;
152 | 		if (currentTestIndex >= amdjsTests.length) {
153 | 			currentTest = null;
154 | 			whenFinishedWithAMDJSTESTS();
155 | 			return;
156 | 		}
157 | 		currentTest = amdjsTests[currentTestIndex];
158 | 
159 | 		// HACK(2) to the loader to get the tests to run as if they were running independently out of their folder
160 | 		require.reset();
161 | 
162 | 		require.config({});
163 | 
164 | 		console.log('<<<<<<<<<<STARTING ' + currentTest.name);
165 | 
166 | 		// Install a 3s timeout in case test never finishes
167 | 		currentTestTimeout = setTimeout(function() {
168 | 			QUnit.start();
169 | 			QUnit.test(currentTest.name, function() {
170 | 				QUnit.ok(false, "Test is taking over 3 seconds");
171 | 			});
172 | 			console.log('>>>>>>>>>>>>');
173 | 			setTimeout(runOneMoreTest, 5);
174 | 		}, 3000);
175 | 
176 | 		require(['_test'], function() {
177 | //			console.log('TEST ' + currentTest + ' should almost be finished (if it has no timeouts).');
178 | 		});
179 | 	}
180 | 
181 | 	QUnit.module('amdjs-tests or ms-specific');
182 | 	runOneMoreTest();
183 | }
184 | 
185 | </script>
186 | 
187 | 	</body>
188 | </html>
189 | 


--------------------------------------------------------------------------------
/tests/run-tests.js:
--------------------------------------------------------------------------------
 1 | var path = require('path');
 2 | var fs = require('fs');
 3 | var control = require('./node-specific/_control');
 4 | var loader = require('./node-specific/_loader');
 5 | 
 6 | var ROOT_DIR = path.join(__dirname, 'node-specific');
 7 | 
 8 | // Discover tests
 9 | var entries = fs.readdirSync(ROOT_DIR);
10 | 
11 | entries = entries.filter(function(entry) {
12 | 	var fullPath = path.join(ROOT_DIR, entry);
13 | 	return fs.statSync(fullPath).isDirectory();
14 | });
15 | 
16 | var currentTest = null;
17 | 
18 | var colors = (function() {
19 | 
20 | 	var _colors = {
21 | 		black: "30",
22 | 		red: "31",
23 | 		green: "32",
24 | 		yellow: "33",
25 | 		blue: "34",
26 | 		magenta: "35",
27 | 		cyan: "36",
28 | 		white: "37",
29 | 	};
30 | 
31 | 
32 | 	var r = {};
33 | 
34 | 	Object.keys(_colors).forEach(function(colorName) {
35 | 		var colorCode = _colors[colorName];
36 | 		r[colorName] = function(str) {
37 | 			return '\x1b[' + colorCode + 'm' + str + '\x1b[0m';
38 | 		}
39 | 	});
40 | 
41 | 	return r;
42 | })();
43 | 
44 | var okCnt = 0, totalCnt = entries.length;
45 | 
46 | function runTest(err) {
47 | 	if (currentTest) {
48 | 		if (err) {
49 | 			console.log(colors.red('[ERROR   ] ' + currentTest + ': \n'), err);
50 | 		} else {
51 | 			okCnt++;
52 | 			console.log(colors.green('[PASSED  ] ' + currentTest + '.'));
53 | 		}
54 | 	}
55 | 
56 | 	if (entries.length > 0) {
57 | 		currentTest = entries.shift();
58 | 		var testModulePath = path.join(ROOT_DIR, currentTest, '_test');
59 | 		loader.reset();
60 | 		try {
61 | 			require(testModulePath);
62 | 		} catch (err) {
63 | 			runTest(err);
64 | 			return;
65 | 		}
66 | 	} else {
67 | 		var str = '[FINISHED] ' + okCnt + '/' + totalCnt + ' passed.';
68 | 		if (okCnt !== totalCnt) {
69 | 			str = colors.red(str);
70 | 		} else {
71 | 			str = colors.green(str);
72 | 		}
73 | 		console.log(str);
74 | 	}
75 | }
76 | 
77 | control.setContinuation(runTest);
78 | runTest(null);
79 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 | 	"compilerOptions": {
 3 | 		"target": "es6",
 4 | 		"newLine": "LF",
 5 | 		"noUnusedLocals": false
 6 | 	},
 7 | 	"files": [
 8 | 		"src/loader.d.ts",
 9 | 		"tests/qunit/qunit.d.ts",
10 | 		"tests/loader.test.ts"
11 | 	],
12 | 	"exclude": [
13 | 		"node_modules"
14 | 	]
15 | }
16 | 


--------------------------------------------------------------------------------