| // Copyright (c) 2015, the Dart project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| |
| // This file defines the module loader for the dart runtime. |
| var dart_library; |
| if (!dart_library) { |
| dart_library = typeof module != 'undefined' && module.exports || {}; |
| |
| (function(dart_library) { |
| 'use strict'; |
| |
| // Throws an error related to module loading. |
| // |
| // This does not throw a Dart error because the Dart SDK may not have loaded |
| // yet, and module loading errors cannot be caught by Dart code. |
| function throwLibraryError(message) { |
| // Dispatch event to allow others to react to the load error without |
| // capturing the exception. |
| if (!!self.dispatchEvent) { |
| self.dispatchEvent( |
| new CustomEvent('dartLoadException', {detail: message})); |
| } |
| throw Error(message); |
| } |
| |
| const libraryImports = Symbol('libraryImports'); |
| dart_library.libraryImports = libraryImports; |
| |
| const _metrics = Symbol('metrics'); |
| const _logMetrics = false; |
| |
| // Returns a map from module name to various metrics for module. |
| function metrics() { |
| const map = {}; |
| const keys = Array.from(_libraries.keys()); |
| for (const key of keys) { |
| const lib = _libraries.get(key); |
| map[lib._name] = lib._library[_metrics]; |
| } |
| return map; |
| } |
| dart_library.metrics = metrics; |
| |
| function _sortFn(key1, key2) { |
| const t1 = _libraries.get(key1)._library[_metrics].loadTime; |
| const t2 = _libraries.get(key2)._library[_metrics].loadTime; |
| return t1 - t2; |
| } |
| |
| // Convenience method to print the metrics in the browser console |
| // in CSV format. |
| function metricsCsv() { |
| let buffer = |
| 'Module, JS Size, Dart Size, Load Time, Cumulative JS Size\n'; |
| const keys = Array.from(_libraries.keys()); |
| keys.sort(_sortFn); |
| let cumulativeJsSize = 0; |
| for (const key of keys) { |
| const lib = _libraries.get(key); |
| const jsSize = lib._library[_metrics].jsSize; |
| cumulativeJsSize += jsSize; |
| const dartSize = lib._library[_metrics].dartSize; |
| const loadTime = lib._library[_metrics].loadTime; |
| buffer += '"' + lib._name + '", ' + jsSize + ', ' + dartSize + ', ' + |
| loadTime + ', ' + cumulativeJsSize + '\n'; |
| } |
| return buffer; |
| } |
| dart_library.metricsCsv = metricsCsv; |
| |
| // Module support. This is a simplified module system for Dart. |
| // Longer term, we can easily migrate to an existing JS module system: |
| // ES6, AMD, RequireJS, .... |
| |
| // Returns a proxy that delegates to the underlying loader. |
| // This defers loading of a module until a library is actually used. |
| const loadedModule = Symbol('loadedModule'); |
| dart_library.defer = function(module, name, patch) { |
| let done = false; |
| function loadDeferred() { |
| done = true; |
| let mod = module[loadedModule]; |
| let lib = mod[name]; |
| // Install unproxied module and library in caller's context. |
| patch(mod, lib); |
| } |
| // The deferred library object. Note, the only legal operations on a Dart |
| // library object should be get (to read a top-level variable, method, or |
| // Class) or set (to write a top-level variable). |
| return new Proxy({}, { |
| get: function(o, p) { |
| if (!done) loadDeferred(); |
| return module[name][p]; |
| }, |
| set: function(o, p, value) { |
| if (!done) loadDeferred(); |
| module[name][p] = value; |
| return true; |
| }, |
| }); |
| }; |
| |
| let _reverseImports = new Map(); |
| |
| // Set of libraries that were not only loaded on the page but also executed. |
| let _executedLibraries = new Set(); |
| |
| class LibraryLoader { |
| constructor(name, defaultValue, imports, loader, data) { |
| imports.forEach(function(i) { |
| let deps = _reverseImports.get(i); |
| if (!deps) { |
| deps = new Set(); |
| _reverseImports.set(i, deps); |
| } |
| deps.add(name); |
| }); |
| this._name = name; |
| this._library = defaultValue ? defaultValue : {}; |
| this._imports = imports; |
| this._loader = loader; |
| data.jsSize = loader.toString().length; |
| data.loadTime = Infinity; |
| this._metrics = data; |
| |
| // Cyclic import detection |
| this._state = LibraryLoader.NOT_LOADED; |
| } |
| |
| loadImports() { |
| let results = []; |
| for (let name of this._imports) { |
| results.push(import_(name)); |
| } |
| return results; |
| } |
| |
| load() { |
| // Check for cycles |
| if (this._state == LibraryLoader.LOADING) { |
| throwLibraryError('Circular dependence on library: ' + this._name); |
| } else if (this._state >= LibraryLoader.READY) { |
| return this._library; |
| } |
| _executedLibraries.add(this._name); |
| this._state = LibraryLoader.LOADING; |
| |
| // Handle imports |
| let args = this.loadImports(); |
| |
| // Load the library |
| let loader = this; |
| let library = this._library; |
| |
| library[libraryImports] = this._imports; |
| library[loadedModule] = library; |
| library[_metrics] = this._metrics; |
| args.unshift(library); |
| |
| if (this._name == 'dart_sdk') { |
| // Eagerly load the SDK. |
| if (!!self.performance) { |
| library[_metrics].loadTime = self.performance.now(); |
| } |
| if (_logMetrics) console.time('Load ' + this._name); |
| this._loader.apply(null, args); |
| if (_logMetrics) console.timeEnd('Load ' + this._name); |
| } else { |
| // Load / parse other modules on demand. |
| let done = false; |
| this._library = new Proxy(library, { |
| get: function(o, name) { |
| if (name == _metrics) { |
| return o[name]; |
| } |
| if (!done) { |
| done = true; |
| if (!!self.performance) { |
| library[_metrics].loadTime = self.performance.now(); |
| } |
| if (_logMetrics) console.time('Load ' + loader._name); |
| loader._loader.apply(null, args); |
| if (_logMetrics) console.timeEnd('Load ' + loader._name); |
| } |
| return o[name]; |
| } |
| }); |
| } |
| |
| this._state = LibraryLoader.READY; |
| return this._library; |
| } |
| |
| stub() { |
| return this._library; |
| } |
| } |
| LibraryLoader.NOT_LOADED = 0; |
| LibraryLoader.LOADING = 1; |
| LibraryLoader.READY = 2; |
| |
| // Map from name to LibraryLoader |
| let _libraries = new Map(); |
| dart_library.libraries = function() { |
| return _libraries.keys(); |
| }; |
| dart_library.debuggerLibraries = function() { |
| let debuggerLibraries = []; |
| _libraries.forEach(function(value, key, map) { |
| debuggerLibraries.push(value.load()); |
| }); |
| debuggerLibraries.__proto__ = null; |
| return debuggerLibraries; |
| }; |
| |
| // Invalidate a library and all things that depend on it |
| function _invalidateLibrary(name) { |
| let lib = _libraries.get(name); |
| if (lib._state == LibraryLoader.NOT_LOADED) return; |
| lib._state = LibraryLoader.NOT_LOADED; |
| lib._library = {}; |
| let deps = _reverseImports.get(name); |
| if (!deps) return; |
| deps.forEach(_invalidateLibrary); |
| } |
| |
| function library(name, defaultValue, imports, loader, data = {}) { |
| let result = _libraries.get(name); |
| if (result) { |
| console.log('Re-loading ' + name); |
| _invalidateLibrary(name); |
| } |
| result = new LibraryLoader(name, defaultValue, imports, loader, data); |
| _libraries.set(name, result); |
| return result; |
| } |
| dart_library.library = library; |
| |
| // Store executed modules upon reload. |
| if (!!self.addEventListener && !!self.localStorage) { |
| self.addEventListener('beforeunload', function(event) { |
| let libraryCache = { |
| 'time': new Date().getTime(), |
| 'modules': Array.from(_executedLibraries.keys()) |
| }; |
| self.localStorage.setItem( |
| 'dartLibraryCache', JSON.stringify(libraryCache)); |
| }); |
| } |
| |
| // Map from module name to corresponding proxy library. |
| let _proxyLibs = new Map(); |
| |
| function import_(name) { |
| let proxy = _proxyLibs.get(name); |
| if (proxy) return proxy; |
| let proxyLib = new Proxy({}, { |
| get: function(o, p) { |
| let lib = _libraries.get(name); |
| if (self.$dartJITModules) { |
| // The backing module changed so update the reference |
| if (!lib) { |
| let xhr = new XMLHttpRequest(); |
| let sourceURL = $dartLoader.moduleIdToUrl.get(name); |
| xhr.open('GET', sourceURL, false); |
| xhr.withCredentials = true; |
| xhr.send(); |
| // Append sourceUrl so the resource shows up in the Chrome |
| // console. |
| eval(xhr.responseText + '//@ sourceURL=' + sourceURL); |
| lib = _libraries.get(name); |
| } |
| } |
| if (!lib) { |
| throwLibraryError('Module ' + name + ' not loaded in the browser.'); |
| } |
| // Always load the library before accessing a property as it may have |
| // been invalidated. |
| return lib.load()[p]; |
| } |
| }); |
| _proxyLibs.set(name, proxyLib); |
| return proxyLib; |
| } |
| dart_library.import = import_; |
| |
| // Removes the corresponding library and invalidates all things that |
| // depend on it. |
| function _invalidateImport(name) { |
| let lib = _libraries.get(name); |
| if (!lib) return; |
| _invalidateLibrary(name); |
| _libraries.delete(name); |
| } |
| dart_library.invalidateImport = _invalidateImport; |
| |
| let _debuggerInitialized = false; |
| |
| // Called to initiate a hot restart of the application. |
| // |
| // "Hot restart" means all application state is cleared, the newly compiled |
| // modules are loaded, and `main()` is called. |
| // |
| // Note: `onReloadEnd()` can be provided, and if so will be used instead of |
| // `main()` for hot restart. |
| // |
| // This happens in the following sequence: |
| // |
| // 1. Look for `onReloadStart()` in the same library that has `main()`, and |
| // call it if present. This function is implemented by the application to |
| // ensure any global browser/DOM state is cleared, so the application can |
| // restart. |
| // 2. Wait for `onReloadStart()` to complete (either synchronously, or async |
| // if it returned a `Future`). |
| // 3. Call dart:_runtime's `hotRestart()` function to clear any state that |
| // `dartdevc` is tracking, such as initialized static fields and type |
| // caches. |
| // 4. Call `window.$dartWarmReload()` (provided by the HTML page) to reload |
| // the relevant JS modules, passing a callback that will invoke `main()`. |
| // 5. `$dartWarmReload` calls the callback to rerun main. |
| // |
| function reload(clearState) { |
| // TODO(jmesserly): once we've rolled out `clearState` make it the |
| // default, and eventually remove the parameter. |
| if (clearState == null) clearState = true; |
| |
| |
| // TODO(jmesserly): we may want to change these APIs to use the |
| // "hot restart" terminology for consistency with Flutter. In Flutter, |
| // "hot reload" refers to keeping the application state and attempting to |
| // patch the code for the application while it is executing |
| // (https://flutter.io/hot-reload/), whereas "hot restart" refers to what |
| // dartdevc supports: tear down the app, update the code, and rerun the |
| // app. |
| if (!self || !self.$dartWarmReload) { |
| console.warn('Hot restart not supported in this environment.'); |
| return; |
| } |
| |
| // Call the application's `onReloadStart()` function, if provided. |
| let result; |
| if (_lastLibrary && _lastLibrary.onReloadStart) { |
| result = _lastLibrary.onReloadStart(); |
| } |
| |
| let sdk = _libraries.get('dart_sdk'); |
| |
| /// Once the `onReloadStart()` completes, this finishes the restart. |
| function finishHotRestart() { |
| self.console.clear(); |
| if (clearState) { |
| // This resets all initialized fields and clears type caches and other |
| // temporary data structures used by the compiler/SDK. |
| sdk._library.dart.hotRestart(); |
| } |
| // Call the module loader to reload the necessary modules. |
| self.$dartWarmReload(() => { |
| // Once the modules are loaded, rerun `main()`. |
| start(_lastModuleName, _lastLibraryName, true); |
| }); |
| } |
| |
| if (result && result.then) { |
| result.then(sdk._library.dart.Dynamic)(finishHotRestart); |
| } else { |
| finishHotRestart(); |
| } |
| } |
| dart_library.reload = reload; |
| |
| |
| let _lastModuleName; |
| let _lastLibraryName; |
| let _lastLibrary; |
| let _originalBody; |
| |
| function start(moduleName, libraryName, isReload) { |
| if (libraryName == null) libraryName = moduleName; |
| _lastModuleName = moduleName; |
| _lastLibraryName = libraryName; |
| let library = import_(moduleName)[libraryName]; |
| _lastLibrary = library; |
| let dart_sdk = import_('dart_sdk'); |
| |
| if (!_debuggerInitialized) { |
| // This import is only needed for chrome debugging. We should provide an |
| // option to compile without it. |
| dart_sdk._debugger.registerDevtoolsFormatter(); |
| |
| // Create isolate. |
| _debuggerInitialized = true; |
| } |
| if (isReload) { |
| if (library.onReloadEnd) { |
| library.onReloadEnd(); |
| return; |
| } else { |
| if (!!self.document) { |
| // Note: we expect _originalBody to be undefined in non-browser |
| // environments, but in that case so is the body. |
| if (!_originalBody && !!self.document.body) { |
| self.console.warn('No body saved to update on reload'); |
| } else { |
| self.document.body = _originalBody; |
| } |
| } |
| } |
| } else { |
| // If not a reload then store the initial html to reset it on reload. |
| if (!!self.document && !!self.document.body) { |
| _originalBody = self.document.body.cloneNode(true); |
| } |
| } |
| library.main([]); |
| } |
| dart_library.start = start; |
| })(dart_library); |
| } |