diff --git a/closure/goog/base.js b/closure/goog/base.js index 310db20f7..03d5ec690 100644 --- a/closure/goog/base.js +++ b/closure/goog/base.js @@ -91,7 +91,14 @@ goog.global.CLOSURE_UNCOMPILED_DEFINES; * var CLOSURE_DEFINES = {'goog.DEBUG': false} ; * * - * @type {Object|undefined} + * Currently the Closure Compiler will only recognize very simple definitions of + * this value when looking for values to apply to compiled code and ignore all + * other references. Specifically, it looks the value defined at the variable + * declaration, as with the example above. + * + * TODO(user): Improve the recognized definitions. + * + * @type {!Object|null|undefined} */ goog.global.CLOSURE_DEFINES; @@ -3175,23 +3182,10 @@ if (!COMPILED && goog.DEPENDENCIES_ENABLED) { scriptEl.nonce = nonce; } - if (goog.DebugLoader_.IS_OLD_IE_) { - // Execution order is not guaranteed on old IE, halt loading and write - // these scripts one at a time, after each loads. - controller.pause(); - scriptEl.onreadystatechange = function() { - if (scriptEl.readyState == 'loaded' || - scriptEl.readyState == 'complete') { - controller.loaded(); - controller.resume(); - } - }; - } else { - scriptEl.onload = function() { - scriptEl.onload = null; - controller.loaded(); - }; - } + scriptEl.onload = function() { + scriptEl.onload = null; + controller.loaded(); + }; scriptEl.src = goog.TRUSTED_TYPES_POLICY_ ? goog.TRUSTED_TYPES_POLICY_.createScriptURL(this.path) : @@ -3502,13 +3496,6 @@ if (!COMPILED && goog.DEPENDENCIES_ENABLED) { // If one thing is pending it is this. var anythingElsePending = controller.pending().length > 1; - // If anything else is loading we need to lazy load due to bugs in old IE. - // Specifically script tags with src and script tags with contents could - // execute out of order if document.write is used, so we cannot use - // document.write. Do not pause here; it breaks old IE as well. - var useOldIeWorkAround = - anythingElsePending && goog.DebugLoader_.IS_OLD_IE_; - // Additionally if we are meant to defer scripts but the page is still // loading (e.g. an ES6 module is loading) then also defer. Or if we are // meant to defer and anything else is pending then defer (those may be @@ -3517,7 +3504,7 @@ if (!COMPILED && goog.DEPENDENCIES_ENABLED) { var needsAsyncLoading = goog.Dependency.defer_ && (anythingElsePending || goog.isDocumentLoading_()); - if (useOldIeWorkAround || needsAsyncLoading) { + if (needsAsyncLoading) { // Note that we only defer when we have to rather than 100% of the time. // Always defering would work, but then in theory the order of // goog.require calls would then matter. We want to enforce that most of @@ -3561,8 +3548,7 @@ if (!COMPILED && goog.DEPENDENCIES_ENABLED) { }; } else { // Always eval on old IE. - if (goog.DebugLoader_.IS_OLD_IE_ || !goog.inHtmlDocument_() || - !goog.isDocumentLoading_()) { + if (!goog.inHtmlDocument_() || !goog.isDocumentLoading_()) { load(); } else { fetchInOwnScriptThenLoad(); @@ -3706,15 +3692,6 @@ if (!COMPILED && goog.DEPENDENCIES_ENABLED) { }; - /** - * Whether the browser is IE9 or earlier, which needs special handling - * for deferred modules. - * @const @private {boolean} - */ - goog.DebugLoader_.IS_OLD_IE_ = !!( - !goog.global.atob && goog.global.document && goog.global.document['all']); - - /** * @param {string} relPath * @param {!Array|undefined} provides diff --git a/closure/goog/goog.js b/closure/goog/goog.js new file mode 100644 index 000000000..9c8d53e88 --- /dev/null +++ b/closure/goog/goog.js @@ -0,0 +1,99 @@ +// Copyright 2018 The Closure Library Authors. All Rights Reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS-IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +/** + * @fileoverview ES6 module that exports symbols from base.js so that ES6 + * modules do not need to use globals and so that is clear if a project is using + * Closure's base.js file. It is also a subset of properties in base.js, meaning + * it should be clearer what should not be used in ES6 modules + * (goog.module/provide are not exported here, for example). Though that is not + * to say that everything in this file should be used in an ES6 module; some + * depreciated functions are exported to make migration easier (e.g. + * goog.scope). + * + * Note that this does not load Closure's base.js file, it is still up to the + * programmer to include it. Nor does the fact that this is an ES6 module mean + * that projects no longer require deps.js files for debug loading - they do. + * Closure will need to load your ES6 modules for you if you have any Closure + * file (goog.provide/goog.module) dependencies, as they need to be available + * before the ES6 module evaluates. + * + * Also note that this file has special compiler handling! It is okay to export + * anything from this file, but the name also needs to exist on the global goog. + * This special compiler pass enforces that you always import this file as + * `import * as goog`, as many tools use regex based parsing to find + * goog.require calls. + */ + +export const global = goog.global; +export const require = goog.require; +export const define = goog.define; +export const DEBUG = goog.DEBUG; +export const LOCALE = goog.LOCALE; +export const TRUSTED_SITE = goog.TRUSTED_SITE; +export const DISALLOW_TEST_ONLY_CODE = goog.DISALLOW_TEST_ONLY_CODE; +export const getGoogModule = goog.module.get; +export const setTestOnly = goog.setTestOnly; +export const forwardDeclare = goog.forwardDeclare; +export const getObjectByName = goog.getObjectByName; +export const basePath = goog.basePath; +export const addSingletonGetter = goog.addSingletonGetter; +export const typeOf = goog.typeOf; +export const isArrayLike = goog.isArrayLike; +export const isDateLike = goog.isDateLike; +export const isObject = goog.isObject; +export const getUid = goog.getUid; +export const hasUid = goog.hasUid; +export const removeUid = goog.removeUid; +export const mixin = goog.mixin; +export const now = Date.now; +export const globalEval = goog.globalEval; +export const getCssName = goog.getCssName; +export const setCssNameMapping = goog.setCssNameMapping; +export const getMsg = goog.getMsg; +export const getMsgWithFallback = goog.getMsgWithFallback; +export const exportSymbol = goog.exportSymbol; +export const exportProperty = goog.exportProperty; +export const nullFunction = goog.nullFunction; +export const abstractMethod = goog.abstractMethod; +export const cloneObject = goog.cloneObject; +export const bind = goog.bind; +export const partial = goog.partial; +export const inherits = goog.inherits; +export const scope = goog.scope; +export const defineClass = goog.defineClass; +export const declareModuleId = goog.declareModuleId; + +// Export select properties of module. Do not export the function itself or +// goog.module.declareLegacyNamespace. +export const module = { + get: goog.module.get, +}; + +// Omissions include: +// goog.ENABLE_DEBUG_LOADER - define only used in base. +// goog.ENABLE_CHROME_APP_SAFE_SCRIPT_LOADING - define only used in base. +// goog.provide - ES6 modules do not provide anything. +// goog.module - ES6 modules cannot be goog.modules. +// goog.module.declareLegacyNamespace - ES6 modules cannot declare namespaces. +// goog.addDependency - meant to only be used by dependency files. +// goog.DEPENDENCIES_ENABLED - constant only used in base. +// goog.TRANSPILE - define only used in base. +// goog.TRANSPILER - define only used in base. +// goog.loadModule - should not be called by any ES6 module; exists for +// generated bundles. +// goog.LOAD_MODULE_USING_EVAL - define only used in base. +// goog.SEAL_MODULE_EXPORTS - define only used in base. +// goog.DebugLoader - used rarely, only outside of compiled code. +// goog.Transpiler - used rarely, only outside of compiled code. diff --git a/tests/deps.js b/tests/deps.js index 958ecff05..3631d4ff3 100644 --- a/tests/deps.js +++ b/tests/deps.js @@ -323,4 +323,5 @@ goog.addDependency('../../generators/python/variables.js', ['Blockly.Python.vari goog.addDependency('../../generators/python/variables_dynamic.js', ['Blockly.Python.variablesDynamic'], ['Blockly.Python', 'Blockly.Python.variables'], {'lang': 'es6', 'module': 'goog'}); goog.addDependency('base.js', [], []); goog.addDependency('base_minimal.js', [], []); +goog.addDependency('goog.js', [], [], {'lang': 'es6', 'module': 'es6'}); diff --git a/tests/playground.html b/tests/playground.html index 171c54d31..0e2a01a70 100644 --- a/tests/playground.html +++ b/tests/playground.html @@ -5,12 +5,12 @@ Blockly Playground - - + - +
diff --git a/tests/playgrounds/blockly.mjs b/tests/playgrounds/blockly.mjs new file mode 100644 index 000000000..dcbc95a6d --- /dev/null +++ b/tests/playgrounds/blockly.mjs @@ -0,0 +1,38 @@ +/** + * @license + * Copyright 2022 Google LLC + * SPDX-License-Identifier: Apache-2.0 + */ + +/** + * @fileoverview Finishes loading Blockly and exports it as this + * module's default export. + * + * It is exported as the default export to avoid having to + * re-export each property on Blockly individually, because you + * can't do: + * + * export * from ; // SYNTAX ERROR + * + * You must use a '); + // Load dependency graph info from test/deps.js. To update + // deps.js, run `npm run build:deps`. + document.write(''); + + // Msg loading kludge. This should go away once #5409 and/or + // #1895 are fixed. + + // Load messages into a temporary Blockly.Msg object, deleting it + // afterwards (after saving the messages!) + window.Blockly = {Msg: Object.create(null)}; + document.write(''); + document.write(` + `); + + document.write(` + `); + } else { + // We need to load Blockly in compiled mode. + + // Load blockly_compressed.js et al. using '); + document.write(''); + document.write(''); + document.write(''); + document.write(''); + document.write(''); + document.write(''); + document.write(''); + } +})();