mirror of https://github.com/flutter/samples.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1248 lines
43 KiB
1248 lines
43 KiB
// 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.
|
|
if (!self.dart_library) {
|
|
self.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);
|
|
}
|
|
|
|
/**
|
|
* Returns true if we're running in d8.
|
|
*
|
|
* TOOD(markzipan): Determine if this d8 check is too inexact.
|
|
*/
|
|
self.dart_library.isD8 = self.document.head == void 0;
|
|
|
|
const libraryImports = Symbol('libraryImports');
|
|
self.dart_library.libraryImports = libraryImports;
|
|
|
|
const _metrics = Symbol('metrics');
|
|
|
|
// Returns a map from module name to various metrics for module.
|
|
function moduleMetrics() {
|
|
const map = {};
|
|
const keys = Array.from(_libraries.keys());
|
|
for (const key of keys) {
|
|
const lib = _libraries.get(key);
|
|
map[lib._name] = lib.firstLibraryValue[_metrics];
|
|
}
|
|
return map;
|
|
}
|
|
self.dart_library.moduleMetrics = moduleMetrics;
|
|
|
|
// Returns an application level overview of the module metrics.
|
|
function appMetrics() {
|
|
const metrics = moduleMetrics();
|
|
let dartSize = 0;
|
|
let jsSize = 0;
|
|
let sourceMapSize = 0;
|
|
let evaluatedModules = 0;
|
|
const keys = Array.from(_libraries.keys());
|
|
|
|
let firstLoadStart = Number.MAX_VALUE;
|
|
let lastLoadEnd = Number.MIN_VALUE;
|
|
|
|
for (const module of keys) {
|
|
let data = metrics[module];
|
|
if (data != null) {
|
|
evaluatedModules++;
|
|
dartSize += data.dartSize;
|
|
jsSize += data.jsSize;
|
|
sourceMapSize += data.sourceMapSize;
|
|
firstLoadStart = Math.min(firstLoadStart, data.loadStart);
|
|
lastLoadEnd = Math.max(lastLoadEnd, data.loadEnd);
|
|
}
|
|
}
|
|
return {
|
|
'dartSize': dartSize,
|
|
'jsSize': jsSize,
|
|
'sourceMapSize': sourceMapSize,
|
|
'evaluatedModules': evaluatedModules,
|
|
'loadTimeMs': lastLoadEnd - firstLoadStart
|
|
};
|
|
}
|
|
self.dart_library.appMetrics = appMetrics;
|
|
|
|
function _sortFn(key1, key2) {
|
|
const t1 = _libraries.get(key1).firstLibraryValue[_metrics].loadStart;
|
|
const t2 = _libraries.get(key2).firstLibraryValue[_metrics].loadStart;
|
|
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 Start, Load End, 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.firstLibraryValue[_metrics].jsSize;
|
|
cumulativeJsSize += jsSize;
|
|
const dartSize = lib.firstLibraryValue[_metrics].dartSize;
|
|
const loadStart = lib.firstLibraryValue[_metrics].loadStart;
|
|
const loadEnd = lib.firstLibraryValue[_metrics].loadEnd;
|
|
buffer += '"' + lib._name + '", ' + jsSize + ', ' + dartSize + ', ' +
|
|
loadStart + ', ' + loadEnd + ', ' + cumulativeJsSize + '\n';
|
|
}
|
|
return buffer;
|
|
}
|
|
self.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');
|
|
self.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();
|
|
|
|
// App name to set of libraries that were not only loaded on the page but
|
|
// also executed.
|
|
const _executedLibraries = new Map();
|
|
self.dart_library.executedLibraryCount = function () {
|
|
let count = 0;
|
|
_executedLibraries.forEach(function (executedLibraries, _) {
|
|
count += executedLibraries.size;
|
|
});
|
|
return count;
|
|
};
|
|
|
|
// Library instance that is going to be loaded or has been loaded.
|
|
class LibraryInstance {
|
|
constructor(libraryValue) {
|
|
this.libraryValue = libraryValue;
|
|
// Cyclic import detection
|
|
this.loadingState = LibraryLoader.NOT_LOADED;
|
|
}
|
|
|
|
get isNotLoaded() {
|
|
return this.loadingState == LibraryLoader.NOT_LOADED;
|
|
}
|
|
}
|
|
|
|
class LibraryLoader {
|
|
constructor(name, defaultLibraryValue, 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._defaultLibraryValue =
|
|
defaultLibraryValue ? defaultLibraryValue : {};
|
|
this._imports = imports;
|
|
this._loader = loader;
|
|
data.jsSize = loader.toString().length;
|
|
data.loadStart = NaN;
|
|
data.loadEnd = NaN;
|
|
this._metrics = data;
|
|
|
|
// First loaded instance for supporting logic that assumes there is only
|
|
// one app.
|
|
// TODO(b/204209941): Remove _firstLibraryInstance after debugger and
|
|
// metrics support multiple apps.
|
|
this._firstLibraryInstance =
|
|
new LibraryInstance(this._deepCopyDefaultValue());
|
|
this._firstLibraryInstanceUsed = false;
|
|
|
|
// App name to instance map.
|
|
this._instanceMap = new Map();
|
|
}
|
|
|
|
/// First loaded value for supporting logic that assumes there is only
|
|
/// one app.
|
|
get firstLibraryValue() {
|
|
return this._firstLibraryInstance.libraryValue;
|
|
}
|
|
|
|
/// The loaded instance value for the given `appName`.
|
|
libraryValueInApp(appName) {
|
|
return this._instanceMap.get(appName).libraryValue;
|
|
}
|
|
|
|
load(appName) {
|
|
let instance = this._instanceMap.get(appName);
|
|
if (!instance && !this._firstLibraryInstanceUsed) {
|
|
// If `_firstLibraryInstance` is already assigned to an app, creates a
|
|
// new instance clone (with deep copy) and assigns it the given app.
|
|
// Otherwise, reuse `_firstLibraryInstance`.
|
|
instance = this._firstLibraryInstance;
|
|
this._firstLibraryInstanceUsed = true;
|
|
this._instanceMap.set(appName, instance);
|
|
}
|
|
if (!instance) {
|
|
instance = new LibraryInstance(this._deepCopyDefaultValue());
|
|
this._instanceMap.set(appName, instance);
|
|
}
|
|
|
|
// Check for cycles
|
|
if (instance.loadingState == LibraryLoader.LOADING) {
|
|
throwLibraryError('Circular dependence on library: ' + this._name);
|
|
} else if (instance.loadingState >= LibraryLoader.READY) {
|
|
return instance.libraryValue;
|
|
}
|
|
if (!_executedLibraries.has(appName)) {
|
|
_executedLibraries.set(appName, new Set());
|
|
}
|
|
_executedLibraries.get(appName).add(this._name);
|
|
instance.loadingState = LibraryLoader.LOADING;
|
|
|
|
// Handle imports
|
|
let args = this._loadImports(appName);
|
|
|
|
// Load the library
|
|
let loader = this;
|
|
let library = instance.libraryValue;
|
|
|
|
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 && !!self.performance.now) {
|
|
library[_metrics].loadStart = self.performance.now();
|
|
}
|
|
this._loader.apply(null, args);
|
|
if (!!self.performance && !!self.performance.now) {
|
|
library[_metrics].loadEnd = self.performance.now();
|
|
}
|
|
} else {
|
|
// Load / parse other modules on demand.
|
|
let done = false;
|
|
instance.libraryValue = new Proxy(library, {
|
|
get: function (o, name) {
|
|
if (name == _metrics) {
|
|
return o[name];
|
|
}
|
|
if (!done) {
|
|
done = true;
|
|
if (!!self.performance && !!self.performance.now) {
|
|
library[_metrics].loadStart = self.performance.now();
|
|
}
|
|
loader._loader.apply(null, args);
|
|
if (!!self.performance && !!self.performance.now) {
|
|
library[_metrics].loadEnd = self.performance.now();
|
|
}
|
|
}
|
|
return o[name];
|
|
}
|
|
});
|
|
}
|
|
|
|
instance.loadingState = LibraryLoader.READY;
|
|
return instance.libraryValue;
|
|
}
|
|
|
|
_loadImports(appName) {
|
|
let results = [];
|
|
for (let name of this._imports) {
|
|
results.push(import_(name, appName));
|
|
}
|
|
return results;
|
|
}
|
|
|
|
_deepCopyDefaultValue() {
|
|
return JSON.parse(JSON.stringify(this._defaultLibraryValue));
|
|
}
|
|
}
|
|
LibraryLoader.NOT_LOADED = 0;
|
|
LibraryLoader.LOADING = 1;
|
|
LibraryLoader.READY = 2;
|
|
|
|
// Map from name to LibraryLoader
|
|
let _libraries = new Map();
|
|
self.dart_library.libraries = function () {
|
|
return _libraries.keys();
|
|
};
|
|
self.dart_library.debuggerLibraries = function () {
|
|
let debuggerLibraries = [];
|
|
_libraries.forEach(function (value, key, map) {
|
|
debuggerLibraries.push(value.load(_firstStartedAppName));
|
|
});
|
|
Object.setPrototypeOf(debuggerLibraries, null);
|
|
return debuggerLibraries;
|
|
};
|
|
|
|
// Invalidate a library and all things that depend on it
|
|
function _invalidateLibrary(name) {
|
|
let lib = _libraries.get(name);
|
|
if (lib._instanceMap.size === 0) return;
|
|
lib._firstLibraryInstance =
|
|
new LibraryInstance(lib._deepCopyDefaultValue());
|
|
lib._firstLibraryInstanceUsed = false;
|
|
lib._instanceMap.clear();
|
|
let deps = _reverseImports.get(name);
|
|
if (!deps) return;
|
|
deps.forEach(_invalidateLibrary);
|
|
}
|
|
|
|
function library(name, defaultLibraryValue, imports, loader, data = {}) {
|
|
let result = _libraries.get(name);
|
|
if (result) {
|
|
console.log('Re-loading ' + name);
|
|
_invalidateLibrary(name);
|
|
}
|
|
result =
|
|
new LibraryLoader(name, defaultLibraryValue, imports, loader, data);
|
|
_libraries.set(name, result);
|
|
return result;
|
|
}
|
|
self.dart_library.library = library;
|
|
|
|
// Store executed modules upon reload.
|
|
if (!!self.addEventListener && !!self.localStorage) {
|
|
self.addEventListener('beforeunload', function (event) {
|
|
_nameToApp.forEach(function (_, appName) {
|
|
if (!_executedLibraries.get(appName)) {
|
|
return;
|
|
}
|
|
let libraryCache = {
|
|
'time': new Date().getTime(),
|
|
'modules': Array.from(_executedLibraries.get(appName).keys()),
|
|
};
|
|
self.localStorage.setItem(
|
|
`dartLibraryCache:${appName}`, JSON.stringify(libraryCache));
|
|
});
|
|
});
|
|
}
|
|
|
|
// Map from module name to corresponding app to proxy library map.
|
|
let _proxyLibs = new Map();
|
|
|
|
function import_(name, appName) {
|
|
// For backward compatibility.
|
|
if (!appName && _lastStartedSubapp) {
|
|
appName = _lastStartedSubapp.appName;
|
|
}
|
|
|
|
let proxy;
|
|
if (_proxyLibs.has(name)) {
|
|
proxy = _proxyLibs.get(name).get(appName);
|
|
}
|
|
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 = self.$dartLoader.moduleIdToUrl.get(name);
|
|
xhr.open('GET', sourceURL, false);
|
|
xhr.withCredentials = true;
|
|
xhr.send();
|
|
// Add inline policy to make eval() call Trusted Types compatible
|
|
// when running in a TT compatible browser
|
|
let policy = {
|
|
createScript: function (script) {
|
|
return script;
|
|
}
|
|
};
|
|
if (self.trustedTypes && self.trustedTypes.createPolicy) {
|
|
policy = self.trustedTypes.createPolicy(
|
|
'dartDdcModuleLoading#dart_library', policy);
|
|
}
|
|
// Append sourceUrl so the resource shows up in the Chrome
|
|
// console.
|
|
eval(policy.createScript(
|
|
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(appName)[p];
|
|
}
|
|
});
|
|
if (!_proxyLibs.has(name)) {
|
|
_proxyLibs.set(name, new Map());
|
|
}
|
|
_proxyLibs.get(name).set(appName, proxyLib);
|
|
return proxyLib;
|
|
}
|
|
self.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);
|
|
}
|
|
self.dart_library.invalidateImport = _invalidateImport;
|
|
|
|
let _debuggerInitialized = false;
|
|
|
|
// Caches the last N runIds to prevent hot reload requests from the same
|
|
// runId from executing more than once.
|
|
const _hotRestartRunIdCache = new Array();
|
|
|
|
// Called to initiate a hot restart of the application for a given uuid. If
|
|
// it is not set, the last started application will be hot restarted.
|
|
//
|
|
// "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 `self.$dartReloadModifiedModules()` (provided by the HTML page)
|
|
// to reload the relevant JS modules, passing a callback that will invoke
|
|
// `main()`.
|
|
// 5. `$dartReloadModifiedModules` calls the callback to rerun main.
|
|
//
|
|
async function hotRestart(config) {
|
|
if (!self || !self.$dartReloadModifiedModules) {
|
|
console.warn('Hot restart not supported in this environment.');
|
|
return;
|
|
}
|
|
|
|
// If `config.runId` is set (e.g. a unique build ID that represent the
|
|
// current build and shared by multiple subapps), skip the following runs
|
|
// with the same id.
|
|
if (config && config.runId) {
|
|
if (_hotRestartRunIdCache.indexOf(config.runId) >= 0) {
|
|
// The run has already started (by other subapp or app)
|
|
return;
|
|
}
|
|
_hotRestartRunIdCache.push(config.runId);
|
|
|
|
// Only cache the runIds for the last N runs. We assume that there are
|
|
// less than N requests with different runId can happen in a very short
|
|
// period of time (e.g. 1 second).
|
|
if (_hotRestartRunIdCache.length > 10) {
|
|
_hotRestartRunIdCache.shift();
|
|
}
|
|
}
|
|
|
|
self.console.clear();
|
|
const sdk = _libraries.get('dart_sdk');
|
|
|
|
// Finds out what apps and their subapps should be hot restarted in
|
|
// their starting order.
|
|
const dirtyAppNames = new Array();
|
|
const dirtySubapps = new Array();
|
|
if (config && config.runId) {
|
|
_nameToApp.forEach(function (app, appName) {
|
|
dirtySubapps.push(...app.uuidToSubapp.values());
|
|
dirtyAppNames.push(appName);
|
|
});
|
|
} else {
|
|
dirtySubapps.push(_lastStartedSubapp);
|
|
dirtyAppNames.push(_lastStartedSubapp.appName);
|
|
}
|
|
|
|
// Invokes onReloadStart for each subapp in reversed starting order.
|
|
const onReloadStartPromises = new Array();
|
|
for (const subapp of dirtySubapps.reverse()) {
|
|
// Call the application's `onReloadStart()` function, if provided.
|
|
if (subapp.library && subapp.library.onReloadStart) {
|
|
const result = subapp.library.onReloadStart();
|
|
if (result && result.then) {
|
|
let resolve;
|
|
onReloadStartPromises.push(new Promise(function (res, _) {
|
|
resolve = res;
|
|
}));
|
|
const dart = sdk.libraryValueInApp(subapp.appName).dart;
|
|
result.then(dart.dynamic, function () {
|
|
resolve();
|
|
});
|
|
}
|
|
}
|
|
}
|
|
// Reverse the subapps back to starting order.
|
|
dirtySubapps.reverse();
|
|
|
|
await Promise.all(onReloadStartPromises);
|
|
|
|
// Invokes SDK `hotRestart` to reset all initialized fields and clears
|
|
// type caches and other temporary data structures used by the
|
|
// compiler/SDK.
|
|
for (const appName of dirtyAppNames) {
|
|
sdk.libraryValueInApp(appName).dart.hotRestart();
|
|
}
|
|
|
|
// Invoke `hotRestart` for the deferred loader to clear load ids and
|
|
// other temporary state.
|
|
if (self.deferred_loader) {
|
|
self.deferred_loader.hotRestart();
|
|
}
|
|
|
|
// Starts the subapps in their starting order.
|
|
for (const subapp of dirtySubapps) {
|
|
// Call the module loader to reload the necessary modules.
|
|
self.$dartReloadModifiedModules(subapp.appName, function () {
|
|
// Once the modules are loaded, rerun `main()`.
|
|
start(
|
|
subapp.appName, subapp.uuid, subapp.moduleName,
|
|
subapp.libraryName, true);
|
|
});
|
|
}
|
|
}
|
|
self.dart_library.reload = hotRestart;
|
|
|
|
// Creates a script with the proper nonce value for strict CSP or noops on
|
|
// invalid platforms.
|
|
self.dart_library.createScript = (function () {
|
|
// Exit early if we aren't modifying an HtmlElement (such as in D8).
|
|
if (self.dart_library.isD8) return;
|
|
// Find the nonce value. (Note, this is only computed once.)
|
|
const scripts = Array.from(document.getElementsByTagName('script'));
|
|
let nonce;
|
|
scripts.some(
|
|
script => (nonce = script.nonce || script.getAttribute('nonce')));
|
|
// If present, return a closure that automatically appends the nonce.
|
|
if (nonce) {
|
|
return function () {
|
|
let script = document.createElement('script');
|
|
script.nonce = nonce;
|
|
return script;
|
|
};
|
|
} else {
|
|
return function () {
|
|
return document.createElement('script');
|
|
};
|
|
}
|
|
})();
|
|
|
|
/// An App contains one or multiple Subapps, all of the subapps share the
|
|
/// same memory copy of library instances, and as a result they share state
|
|
/// in Dart statics and top-level fields. There can be one or multiple Apps
|
|
/// in a browser window, all of the Apps are isolated from each other
|
|
/// (i.e. they create different instances even for the same module).
|
|
class App {
|
|
constructor(name) {
|
|
this.name = name;
|
|
|
|
// Subapp's uuid to subapps in initial starting order.
|
|
// (ES6 preserves iteration order)
|
|
this.uuidToSubapp = new Map();
|
|
}
|
|
}
|
|
|
|
class Subapp {
|
|
constructor(uuid, appName, moduleName, libraryName, library) {
|
|
this.uuid = uuid;
|
|
this.appName = appName;
|
|
this.moduleName = moduleName;
|
|
this.libraryName = libraryName;
|
|
this.library = library;
|
|
|
|
this.originalBody = null;
|
|
}
|
|
}
|
|
|
|
// App name to App map in initial starting order.
|
|
// (ES6 preserves iteration order)
|
|
const _nameToApp = new Map();
|
|
let _firstStartedAppName;
|
|
let _lastStartedSubapp;
|
|
|
|
/// Starts a subapp that is identified with `uuid`, `moduleName`, and
|
|
/// `libraryName` inside a parent app that is identified by `appName`.
|
|
function start(appName, uuid, moduleName, libraryName, isReload) {
|
|
console.info(
|
|
`DDC: Subapp Module [${appName}:${moduleName}:${uuid}] is starting`);
|
|
if (libraryName == null) libraryName = moduleName;
|
|
const library = import_(moduleName, appName)[libraryName];
|
|
|
|
let app = _nameToApp.get(appName);
|
|
if (!isReload) {
|
|
if (!app) {
|
|
app = new App(appName);
|
|
_nameToApp.set(appName, app);
|
|
}
|
|
|
|
let subapp = app.uuidToSubapp.get(uuid);
|
|
if (!subapp) {
|
|
subapp = new Subapp(uuid, appName, moduleName, libraryName, library);
|
|
app.uuidToSubapp.set(uuid, subapp);
|
|
}
|
|
|
|
_lastStartedSubapp = subapp;
|
|
if (!_firstStartedAppName) {
|
|
_firstStartedAppName = appName;
|
|
}
|
|
}
|
|
|
|
const subapp = app.uuidToSubapp.get(uuid);
|
|
const sdk = import_('dart_sdk', appName);
|
|
|
|
if (!_debuggerInitialized) {
|
|
// This import is only needed for chrome debugging. We should provide an
|
|
// option to compile without it.
|
|
sdk._debugger.registerDevtoolsFormatter();
|
|
|
|
// Create isolate.
|
|
_debuggerInitialized = true;
|
|
}
|
|
if (isReload) {
|
|
// subapp may have been modified during reload, `subapp.library` needs
|
|
// to always point to the latest data.
|
|
subapp.library = library;
|
|
|
|
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 (!subapp.originalBody && !!self.document.body) {
|
|
self.console.warn('No body saved to update on reload');
|
|
} else {
|
|
self.document.body = subapp.originalBody;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
// If not a reload and `onReloadEnd` is not defined, store the initial
|
|
// html to reset it on reload.
|
|
if (!library.onReloadEnd && !!self.document && !!self.document.body) {
|
|
subapp.originalBody = self.document.body.cloneNode(true);
|
|
}
|
|
}
|
|
library.main([]);
|
|
}
|
|
dart_library.start = start;
|
|
})(dart_library);
|
|
}
|
|
|
|
// Initialize the DDC module loader.
|
|
//
|
|
// Scripts are JS objects with the following structure:
|
|
// {"src": "path/to/script.js", "id": "lookup_id_for_script"}
|
|
(function () {
|
|
let _currentDirectory = (function () {
|
|
let _url = document.currentScript.src;
|
|
let lastSlash = _url.lastIndexOf('/');
|
|
if (lastSlash == -1) return _url;
|
|
let currentDirectory = _url.substring(0, lastSlash + 1);
|
|
return currentDirectory;
|
|
})();
|
|
|
|
let trimmedDirectory = _currentDirectory.endsWith("/") ?
|
|
_currentDirectory.substring(0, _currentDirectory.length - 1)
|
|
: _currentDirectory;
|
|
|
|
if (!self.$dartLoader) {
|
|
self.$dartLoader = {
|
|
// Maps cosmetic (but stable) module names to their fully resolved URL.
|
|
//
|
|
// TODO(markzipan): Multi-app scripts can have module name conflicts.
|
|
// This should ideally be separated per-app.
|
|
moduleIdToUrl: new Map(),
|
|
// Contains root directories below which scripts are resolved.
|
|
rootDirectories: new Array(),
|
|
// This mapping is required for proper translation of stack traces.
|
|
urlToModuleId: new Map(),
|
|
// The DDCLoader used for this app. Should not be used in multi-app
|
|
// scenarios.
|
|
loader: null,
|
|
// The LoadConfiguration used for this app's DDCLoader. Should not be used
|
|
// in multi-app scenarios.
|
|
loadConfig: null
|
|
};
|
|
|
|
// Every distinct DDC app requires its own load configuration.
|
|
self.$dartLoader.LoadConfiguration = class LoadConfiguration {
|
|
constructor() {
|
|
// Identifies the bootstrap script.
|
|
// This should be set by bootstrappers for bootstrap-specific hooks.
|
|
this.bootstrapScript = null;
|
|
|
|
// True if the bootstrap script should be loaded on the this attempt.
|
|
this.tryLoadBootstrapScript = false;
|
|
|
|
// The underlying function that loads scripts.
|
|
//
|
|
// @param {function(!DDCLoader)}
|
|
this.loadScriptFn = (_) => { };
|
|
|
|
// The root for script URLs. Defaults to the root of this file.
|
|
//
|
|
// TODO(markzipan): Using the default is not safe in a multi-app scenario
|
|
// due to apps clobbering state on dartLoader. Move this to the local
|
|
// DDCLoader, which is unique per-app.
|
|
this.root = trimmedDirectory;
|
|
|
|
this.isWindows = false;
|
|
|
|
// Optional event handlers.
|
|
// Called when modules begin loading.
|
|
this.onLoadStart = () => { };
|
|
// Called when the app fails to load after retrying.
|
|
this.onLoadError = () => { };
|
|
// Called if loading the bootstrap script is successful.
|
|
this.onBootstrapSuccess = () => { };
|
|
// Called if the bootstrap script fails to load.
|
|
this.onBootstrapError = () => { };
|
|
|
|
this.maxRequestPoolSize = 1000;
|
|
|
|
// Max retry to prevent from load failing scripts forever.
|
|
this.maxAttempts = 6;
|
|
}
|
|
};
|
|
}
|
|
|
|
// Loads a single script onto the page.
|
|
// TODO(markzipan): Is there a cleaner way to integrate this?
|
|
self.$dartLoader.forceLoadScript = function (jsFile) {
|
|
if (self.dart_library.isD8) {
|
|
self.load(jsFile);
|
|
return;
|
|
}
|
|
let script = self.dart_library.createScript();
|
|
let policy = {
|
|
createScriptURL: function (src) { return src; }
|
|
};
|
|
if (self.trustedTypes && self.trustedTypes.createPolicy) {
|
|
policy = self.trustedTypes.createPolicy('dartDdcModuleUrl', policy);
|
|
}
|
|
script.setAttribute('src', policy.createScriptURL(jsFile));
|
|
document.head.appendChild(script);
|
|
};
|
|
|
|
self.$dartLoader.forceLoadModule = function (moduleName) {
|
|
let modulePathScript = _currentDirectory + moduleName + '.js';
|
|
self.$dartLoader.forceLoadScript(modulePathScript);
|
|
};
|
|
|
|
// Handles JS script downloads and evaluation for a DDC app.
|
|
//
|
|
// Every DDC application requires exactly one DDCLoader.
|
|
self.$dartLoader.DDCLoader = class DDCLoader {
|
|
constructor(loadConfig) {
|
|
this.attemptCount = 0;
|
|
|
|
this.loadConfig = loadConfig;
|
|
|
|
// Scripts that await to be loaded.
|
|
this.queue = new Array();
|
|
|
|
// These refer to scripts already added to the document (as script tag).
|
|
this.numToLoad = 0;
|
|
this.numLoaded = 0;
|
|
this.numFailed = 0;
|
|
|
|
// Resets all the fields and makes a load attempt.
|
|
this.nextAttempt = function () {
|
|
if (this.attemptCount == 0) {
|
|
this.loadConfig.onLoadStart();
|
|
}
|
|
this.attemptCount++;
|
|
this.queue = new Array();
|
|
this.numToLoad = 0;
|
|
this.numLoaded = 0;
|
|
this.numFailed = 0;
|
|
|
|
this.loadConfig.loadScriptFn(this);
|
|
};
|
|
|
|
// The current hot restart generation.
|
|
//
|
|
// 0-indexed and increases by 1 on every successful hot restart.
|
|
// This value is read to determine the 'current' hot restart generation
|
|
// in our hot restart tests. This closely tracks but is not the same as
|
|
// `hotRestartIteration` in DDC's runtime.
|
|
this.hotRestartGeneration = 0;
|
|
|
|
// The current 'intended' hot restart generation.
|
|
//
|
|
// 0-indexed and increases by 1 on every successful hot restart.
|
|
// Unlike `hotRestartGeneration`, this is incremented when the intent to
|
|
// perform a hot restart is established.
|
|
// This is used to synchronize D8 timers and lookup files to load in
|
|
// each generation for hot restart testing.
|
|
this.intendedHotRestartGeneration = 0;
|
|
|
|
// The current hot reload generation.
|
|
//
|
|
// 0-indexed and increases by 1 on every successful hot reload.
|
|
this.hotReloadGeneration = 0;
|
|
}
|
|
|
|
// True if we are still processing scripts from the script queue.
|
|
// 'Processing' means the script is 1) currently being downloaded/parsed
|
|
// or 2) the script failed to download and is being retried.
|
|
scriptsActivelyBeingLoaded() {
|
|
return this.numToLoad > this.numLoaded + this.numFailed;
|
|
};
|
|
|
|
// Joins path segments from the root directory to [script]'s path to get a
|
|
// complete URL.
|
|
getScriptUrl(script) {
|
|
let pathSlash = this.loadConfig.isWindows ? "\\" : "/";
|
|
// Get path segments for src
|
|
let splitSrc = script.src.toString().split(pathSlash);
|
|
let j = 0;
|
|
// Count number of relative path segments
|
|
while (splitSrc[j] == "..") {
|
|
j++;
|
|
}
|
|
// Get path segments for root directory
|
|
let splitDir = !this.loadConfig.root
|
|
|| this.loadConfig.root == pathSlash ? []
|
|
: this.loadConfig.root.split(pathSlash);
|
|
// Account for relative path from the root directory
|
|
let splitPath = splitDir
|
|
.slice(0, splitDir.length - j)
|
|
.concat(splitSrc.slice(j));
|
|
// Join path segments to get a complete path
|
|
return splitPath.join(pathSlash);
|
|
};
|
|
|
|
// Adds [script] to the dartLoader's internals as if it had been loaded and
|
|
// returns its fully resolved source path.
|
|
//
|
|
// Should be called when scripts are loaded on the page externally from
|
|
// dartLoader's API.
|
|
registerScript(script) {
|
|
const src = this.getScriptUrl(script);
|
|
// TODO(markzipan): moduleIdToUrl and urlToModuleId may conflict in
|
|
// multi-app scenarios. Fix this by moving them into the DDCLoader.
|
|
self.$dartLoader.moduleIdToUrl.set(script.id, src);
|
|
self.$dartLoader.urlToModuleId.set(src, script.id);
|
|
return src;
|
|
};
|
|
|
|
// Adds [scripts] to [queue] according to validation function [allowScriptFn].
|
|
//
|
|
// Scripts aren't loaded until loadEnqueuedModules is called.
|
|
addScriptsToQueue(scripts, allowScriptFn) {
|
|
for (let i = 0; i < scripts.length; i++) {
|
|
const script = scripts[i];
|
|
|
|
// Only load the bootstrap script after every other script has finished loading.
|
|
if (script.src == this.loadConfig.bootstrapScript.src) {
|
|
this.loadConfig.tryLoadBootstrapScript = true;
|
|
continue;
|
|
}
|
|
// Skip loading already-loaded scripts.
|
|
if (script.id == null || self.$dartLoader.moduleIdToUrl.has(script.id)) {
|
|
continue;
|
|
}
|
|
|
|
// Register this script's resolved URL.
|
|
let resolvedSrc = this.registerScript(script);
|
|
|
|
// Deferred scripts should be registered but not added during bootstrap.
|
|
if (self.$dartLoader.bootstrapModules !== void 0 &&
|
|
!self.$dartLoader.bootstrapModules.has(script.id)) {
|
|
continue;
|
|
}
|
|
|
|
if (!allowScriptFn || allowScriptFn(script)) {
|
|
this.queue.push({ id: script.id, src: resolvedSrc });
|
|
}
|
|
}
|
|
|
|
if (this.queue.length > 0) {
|
|
console.info(
|
|
`DDC is about to load ${this.queue.length}/${scripts.length} scripts with pool size = ${this.loadConfig.maxRequestPoolSize}`);
|
|
}
|
|
};
|
|
|
|
// Creates a script element to be loaded into the provided container.
|
|
createAndLoadScript(src, id, container, onError, onLoad) {
|
|
let el = self.dart_library.createScript();
|
|
el.src = policy.createScriptURL(src);
|
|
el.async = false;
|
|
el.defer = true;
|
|
el.id = id;
|
|
el.onerror = onError;
|
|
el.onload = onLoad;
|
|
container.appendChild(el);
|
|
};
|
|
|
|
// Retrieves scripts from the loader queue, with at most [maxRequests]
|
|
// outgoing requests.
|
|
//
|
|
// TODO(markzipan): Rewrite this with a promise pool.
|
|
loadMore(maxRequests) {
|
|
let fragment = document.createDocumentFragment();
|
|
let inflightRequests = 0;
|
|
while (this.queue.length > 0 && inflightRequests++ < maxRequests) {
|
|
const script = this.queue.shift();
|
|
this.numToLoad++;
|
|
this.createAndLoadScript(
|
|
script.src.toString(),
|
|
script.id,
|
|
fragment,
|
|
this.onError.bind(this),
|
|
this.onLoad.bind(this)
|
|
);
|
|
}
|
|
if (inflightRequests > 0) {
|
|
document.head.appendChild(fragment);
|
|
} else if (!this.scriptsActivelyBeingLoaded()) {
|
|
this.loadBootstrapJs();
|
|
}
|
|
};
|
|
|
|
loadOneMore() {
|
|
if (this.queue.length > 0) {
|
|
this.loadMore(1);
|
|
}
|
|
};
|
|
|
|
// Loads modules when running with Chrome.
|
|
loadEnqueuedModules() {
|
|
this.loadMore(this.loadConfig.maxRequestPoolSize);
|
|
};
|
|
|
|
// Loads modules when running with d8.
|
|
loadEnqueuedModulesForD8() {
|
|
if (!self.dart_library.isD8) {
|
|
throw Error("'loadEnqueuedModulesForD8' is only supported in D8.");
|
|
}
|
|
// Load all enqueued scripts sequentially.
|
|
for (let i = 0; i < this.queue.length; i++) {
|
|
const script = this.queue[i];
|
|
self.load(script.src.toString());
|
|
}
|
|
this.queue.length = 0;
|
|
// Load the bootstrapper script if it wasn't already loaded.
|
|
if (this.loadConfig.tryLoadBootstrapScript) {
|
|
const script = this.loadConfig.bootstrapScript;
|
|
const src = this.registerScript(script);
|
|
self.load(src);
|
|
this.loadConfig.tryLoadBootstrapScript = false;
|
|
}
|
|
return;
|
|
};
|
|
|
|
// Loads just the bootstrap script.
|
|
//
|
|
// The bootstrapper is loaded only after all other scripts are loaded.
|
|
loadBootstrapJs() {
|
|
if (!this.loadConfig.tryLoadBootstrapScript) {
|
|
return;
|
|
}
|
|
const script = this.loadConfig.bootstrapScript;
|
|
const src = this.registerScript(script);
|
|
this.createAndLoadScript(src, script.id, document.head, null, null);
|
|
this.loadConfig.tryLoadBootstrapScript = false;
|
|
};
|
|
|
|
// Loads/retries compiled JS scripts.
|
|
//
|
|
// Should always be called after a script is loaded or errors.
|
|
processAfterLoadOrErrorEvent() {
|
|
if (this.scriptsActivelyBeingLoaded()) {
|
|
if (this.numFailed == 0) {
|
|
this.loadOneMore();
|
|
} else if (this.attemptCount > this.maxAttempts) {
|
|
// Some scripts have failed to load. Continue loading the rest.
|
|
this.loadOneMore();
|
|
} else {
|
|
// Some scripts have failed to load, but we can still make another
|
|
// load attempt. Wait for scheduled scripts to finish.
|
|
}
|
|
return;
|
|
}
|
|
|
|
// Retry failed scripts to a limit, then load the bootstrap script.
|
|
if (this.numFailed == 0) {
|
|
this.loadBootstrapJs();
|
|
return;
|
|
}
|
|
// Reload whatever failed if maxAttempts is not reached.
|
|
if (this.numFailed > 0) {
|
|
if (this.attemptCount <= this.loadConfig.maxAttempts) {
|
|
this.nextAttempt();
|
|
} else {
|
|
console.error(
|
|
`Failed to load DDC scripts after ${this.loadConfig.maxAttempts} tries`);
|
|
this.loadConfig.onLoadError();
|
|
this.loadBootstrapJs();
|
|
}
|
|
}
|
|
};
|
|
|
|
onLoad(e) {
|
|
this.numLoaded++;
|
|
if (e.target.src == this.loadConfig.bootstrapScript.src) {
|
|
this.loadConfig.onBootstrapSuccess();
|
|
}
|
|
this.processAfterLoadOrErrorEvent();
|
|
};
|
|
|
|
onError(e) {
|
|
this.numFailed++;
|
|
const target = e.target;
|
|
self.$dartLoader.moduleIdToUrl.delete(target.id);
|
|
self.$dartLoader.urlToModuleId.delete(target.src);
|
|
self.deferred_loader.clearModule(target.id);
|
|
|
|
if (target.src == this.loadConfig.bootstrapScript.src) {
|
|
this.loadConfig.onBootstrapError();
|
|
}
|
|
this.processAfterLoadOrErrorEvent();
|
|
};
|
|
|
|
// Initiates a hot reload.
|
|
// TODO(markzipan): This function is currently stubbed out for testing.
|
|
hotReload() {
|
|
this.hotReloadGeneration += 1;
|
|
}
|
|
|
|
// Initiates a hot restart.
|
|
hotRestart() {
|
|
this.intendedHotRestartGeneration += 1;
|
|
self.dart_library.reload();
|
|
}
|
|
};
|
|
|
|
let policy = {
|
|
createScriptURL: function (src) { return src; }
|
|
};
|
|
|
|
if (self.trustedTypes && self.trustedTypes.createPolicy) {
|
|
policy = self.trustedTypes.createPolicy("dartDdcModuleUrl", policy);
|
|
}
|
|
|
|
self.$dartLoader.loadScripts = function (scripts, loader) {
|
|
loader.loadConfig.loadScriptFn = function (loader) {
|
|
loader.addScriptsToQueue(scripts, null);
|
|
loader.loadEnqueuedModules();
|
|
};
|
|
loader.nextAttempt();
|
|
};
|
|
})();
|
|
|
|
if (!self.deferred_loader) {
|
|
self.deferred_loader = {
|
|
// Module IDs already loaded on the page (e.g., during bootstrap or after
|
|
// loadLibrary is called).
|
|
loadedModules: new Set(),
|
|
// An import graph of all direct imports (not deferred).
|
|
moduleGraph: new Map(),
|
|
// Maps module IDs to their resolved urls.
|
|
moduleToUrl: new Map(),
|
|
// Module IDs mapped to their resolved or resolving promises.
|
|
moduleToPromise: new Map(),
|
|
// Deferred libraries on which 'loadLibrary' have already been called.
|
|
// Load Ids are a composite of the URI of originating load's library and
|
|
// the target library name.
|
|
loadIds: new Set(),
|
|
};
|
|
|
|
/**
|
|
* Must be called before 'main' to initialize the deferred loader.
|
|
* @param {!Map<string, string>} moduleToUrlMapping
|
|
* @param {!Map<string, !Array<string>>} moduleGraph non-deferred import graph
|
|
* @param {!Array<string>} loadedModules moduled loaded during bootstrap
|
|
*/
|
|
self.deferred_loader.initDeferredLoader = function (
|
|
moduleToUrlMapping, moduleGraph, loadedModules) {
|
|
self.deferred_loader.moduleToUrl = moduleToUrlMapping;
|
|
self.deferred_loader.moduleGraph = moduleGraph;
|
|
for (let i = 0; i < loadedModules.length; i++) {
|
|
let module = loadedModules[i];
|
|
self.deferred_loader.loadedModules.add(module);
|
|
self.deferred_loader.moduleToPromise.set(module, Promise.resolve());
|
|
}
|
|
};
|
|
|
|
/**
|
|
* Returns all modules downstream of [moduleId] that are visible
|
|
* (i.e., not deferred) and have not already been loaded.
|
|
* @param {string} moduleId
|
|
* @return {!Array<string>} module IDs that must be loaded with [moduleId]
|
|
*/
|
|
let dependenciesToLoad = function (moduleId) {
|
|
let stack = [moduleId];
|
|
let seen = new Set();
|
|
while (stack.length > 0) {
|
|
let module = stack.pop();
|
|
if (seen.has(module)) continue;
|
|
seen.add(module);
|
|
stack = stack.concat(self.deferred_loader.moduleGraph.get(module));
|
|
}
|
|
let dependencies = [];
|
|
seen.forEach(module => {
|
|
if (self.deferred_loader.loadedModules.has(module)) return;
|
|
dependencies.push(module);
|
|
});
|
|
return dependencies;
|
|
};
|
|
|
|
/**
|
|
* Loads [moduleUrl] onto this instance's DDC app's page, then invokes
|
|
* [onLoad].
|
|
* @param {string} moduleUrl
|
|
* @param {function()} onLoad Callback after a successful load
|
|
*/
|
|
let loadScript = function (moduleUrl, onLoad) {
|
|
// A head element won't be created for D8, so just load synchronously.
|
|
if (self.dart_library.isD8) {
|
|
self.load(moduleUrl);
|
|
onLoad();
|
|
return;
|
|
}
|
|
let script = dart_library.createScript();
|
|
let policy = {
|
|
createScriptURL: function (src) {
|
|
return src;
|
|
}
|
|
};
|
|
if (self.trustedTypes && self.trustedTypes.createPolicy) {
|
|
policy = self.trustedTypes.createPolicy('dartDdcModuleUrl', policy);
|
|
}
|
|
script.setAttribute('src', policy.createScriptURL(moduleUrl));
|
|
script.async = false;
|
|
script.defer = true;
|
|
script.onload = onLoad;
|
|
self.document.head.appendChild(script);
|
|
};
|
|
|
|
/**
|
|
* Performs a deferred load, calling [onSuccess] or [onError] callbacks when
|
|
* the deferred load completes or fails, respectively.
|
|
* @param {string} loadId {library URI}:{resource name being loaded}
|
|
* @param {string} targetModule moduleId of the resource requested by [loadId]
|
|
* @param {function(function())} onSuccess callback after a successful load
|
|
* @param {function(!Error)} onError callback after a failed load
|
|
*/
|
|
self.deferred_loader.loadDeferred = function (
|
|
loadId, targetModule, onSuccess, onError) {
|
|
// loadLibrary had already been called, and its module has already been
|
|
// loaded, so just complete the future.
|
|
if (self.deferred_loader.loadIds.has(loadId)) {
|
|
onSuccess();
|
|
return;
|
|
}
|
|
|
|
// The module's been loaded, so mark this import as loaded and finish.
|
|
if (self.deferred_loader.loadedModules.has(targetModule)) {
|
|
self.deferred_loader.loadIds.add(loadId);
|
|
onSuccess();
|
|
return;
|
|
}
|
|
|
|
// The import's module has not been loaded, so load it and its dependencies
|
|
// before completing the callback.
|
|
let modulesToLoad = dependenciesToLoad(targetModule);
|
|
Promise
|
|
.all(modulesToLoad.map(module => {
|
|
let url = self.deferred_loader.moduleToUrl.get(module);
|
|
if (url === void 0) {
|
|
console.log('Unable to find URL for module: ' + module);
|
|
return;
|
|
}
|
|
let promise = self.deferred_loader.moduleToPromise.get(module);
|
|
if (promise !== void 0) return promise;
|
|
self.deferred_loader.moduleToPromise.set(
|
|
module,
|
|
new Promise((resolve) => loadScript(url, () => {
|
|
self.deferred_loader.loadedModules.add(module);
|
|
resolve();
|
|
})));
|
|
return self.deferred_loader.moduleToPromise.get(module);
|
|
}))
|
|
.then(() => {
|
|
onSuccess(() => self.deferred_loader.loadIds.add(loadId));
|
|
})
|
|
.catch((error) => {
|
|
onError(error.message);
|
|
});
|
|
};
|
|
|
|
/**
|
|
* Returns whether or not the module containing [loadId] has finished loading.
|
|
* @param {string} loadId library URI concatenated with the resource being
|
|
* loaded
|
|
* @return {boolean}
|
|
*/
|
|
self.deferred_loader.isLoaded = function (loadId) {
|
|
return self.deferred_loader.loadIds.has(loadId);
|
|
};
|
|
|
|
/**
|
|
* Removes references to [moduleId] in the deferred loader.
|
|
* @param {string} moduleId
|
|
*
|
|
* TODO(markzipan): Determine how deep we should clear moduleId's references.
|
|
*/
|
|
self.deferred_loader.clearModule = function (moduleId) {
|
|
self.deferred_loader.loadedModules.delete(moduleId);
|
|
self.deferred_loader.moduleToUrl.delete(moduleId);
|
|
self.deferred_loader.moduleToPromise.delete(moduleId);
|
|
};
|
|
|
|
/**
|
|
* Clears state required for hot restart.
|
|
*/
|
|
self.deferred_loader.hotRestart = function () {
|
|
self.deferred_loader.loadIds = new Set();
|
|
};
|
|
}
|