NPM distribution (#2780)

* Add NPM distribution tasks.

.gitignore

@@ -12,3 +12,4 @@ tests/compile/main_compressed.js
 tests/compile/*compiler*.jar
 local_build/*compiler*.jar
 local_build/local_*_compressed.js
+dist/

gulpfile.js

@@ -26,7 +26,16 @@
 var gulp = require('gulp');
 gulp.shell = require('gulp-shell');
 gulp.concat = require('gulp-concat');
-var insert = require('gulp-insert');
+gulp.replace = require('gulp-replace');
+gulp.rename = require('gulp-rename');
+gulp.insert = require('gulp-insert');
+gulp.umd = require('gulp-umd');
+
+var path = require('path');
+var fs = require('fs');
+var rimraf = require('rimraf');
+var execSync = require('child_process').execSync;
+
 
 // Rebuilds Blockly, including the following:
 //  - blockly_compressed.js
@@ -48,7 +57,7 @@ gulp.task('build', gulp.shell.task([
 // and JavaScript code generation.  If you need another localization or
 // generator language, just copy and edit the srcs. Only one localization
 // language can be included.
-gulp.task('blockly_javascript_en', function() {
+gulp.task('blockly_node_javascript_en', function() {
   var srcs = [
     'blockly_compressed.js',
     'blocks_compressed.js',
@@ -59,7 +68,7 @@ gulp.task('blockly_javascript_en', function() {
   // Override textToDomDocument, providing Node alternative to DOMParser.
   return gulp.src(srcs)
       .pipe(gulp.concat('blockly_node_javascript_en.js'))
-      .pipe(insert.append(`
+      .pipe(gulp.insert.append(`
 if (typeof DOMParser !== 'function') {
   var JSDOM = require('jsdom').JSDOM;
   var window = (new JSDOM()).window;
@@ -106,8 +115,448 @@ function buildWatchTaskFn(concatTask) {
 
 // Watch Blockly files for changes and trigger automatic rebuilds, including
 // the Node-ready blockly_node_javascript_en.js file.
-gulp.task('watch', buildWatchTaskFn('blockly_javascript_en'));
+gulp.task('watch', buildWatchTaskFn('blockly_node_javascript_en'));
+
+////////////////////////////////////////////////////////////
+//                        Typings                         //
+////////////////////////////////////////////////////////////
+
+// Generates the TypeScript definition file (d.ts) for Blockly.
+// As well as generating the typings of each of the files under core/ and msg/,
+// the script also pulls in a number of part files from typings/parts.
+// This includes the header (incl License), additional useful interfaces
+// including Blockly Options and Google Closure typings
+gulp.task('typings', function (cb) {
+  const tmpDir = './typings/tmp';
+  const blocklySrcs = [
+    "core/",
+    "core/theme",
+    "core/utils",
+    "msg/"
+  ];
+  // Clean directory if exists
+  if (fs.existsSync(tmpDir)) {
+    rimraf.sync(tmpDir);
+  }
+  fs.mkdirSync(tmpDir);
+
+  // Find all files that will be included in the typings file
+  let files = [];
+  blocklySrcs.forEach((src) => {
+    files = files.concat(fs.readdirSync(src)
+      .filter(fn => fn.endsWith('.js'))
+      .map(fn => path.join(src, fn)));
+  });
+
+  // Generate typings file for each file
+  files.forEach((file) => {
+    const typescriptFileName = `${path.join(tmpDir, file)}.d.ts`;
+    const cmd = `node ./node_modules/typescript-closure-tools/definition-generator/src/main.js ${file} ${typescriptFileName}`;
+    console.log(`Generating typings for ${file}`);
+    execSync(cmd, { stdio: 'inherit' });
+  });
+
+  const srcs = [
+    'typings/parts/blockly-header.d.ts',
+    'typings/parts/blockly-interfaces.d.ts',
+    'typings/parts/goog-closure.d.ts',
+    `${tmpDir}/core/**`,
+    `${tmpDir}/core/utils/**`,
+    `${tmpDir}/core/theme/**`,
+    `${tmpDir}/msg/**`
+  ];
+  return gulp.src(srcs)
+    .pipe(gulp.concat('blockly.d.ts'))
+    .pipe(gulp.dest('typings'))
+    .on('end', function () {
+      // Clean up tmp directory
+      if (fs.existsSync(tmpDir)) {
+        rimraf.sync(tmpDir);
+      }
+    });
+});
+
+////////////////////////////////////////////////////////////
+//                  NPM packaging tasks                   //
+////////////////////////////////////////////////////////////
+
+// The destination path where all the NPM distribution files will go.
+const packageDistribution = './dist';
+
+/**
+ * A helper method for wrapping a file into a Universal Module Definition.
+ * @param {string} namespace The export namespace.
+ * @param {Array<Object>} dependencies An array of dependencies to inject.
+ */
+function packageUMD(namespace, dependencies) {
+  return gulp.umd({
+    dependencies: function () { return dependencies; },
+    namespace: function () { return namespace; },
+    exports: function () { return namespace; },
+    template: path.join(__dirname, 'package/templates/umd.template')
+  });
+};
+
+/**
+ * A helper method for wrapping a file into a CommonJS module for Node.js.
+ * @param {string} namespace The export namespace.
+ * @param {Array<Object>} dependencies An array of dependencies to inject.
+ */
+function packageCommonJS(namespace, dependencies) {
+  return gulp.umd({
+    dependencies: function () { return dependencies; },
+    namespace: function () { return namespace; },
+    exports: function () { return namespace; },
+    template: path.join(__dirname, 'package/templates/node.template')
+  });
+};
+
+/**
+ * This task wraps blockly_compressed.js into a UMD module.
+ * @example import 'blockly/blockly';
+ */
+gulp.task('package-blockly', function() {
+  return gulp.src('blockly_compressed.js')
+    .pipe(gulp.insert.prepend(`
+    var self = this;`))
+    .pipe(packageUMD('Blockly', []))
+    .pipe(gulp.rename('blockly.js'))
+    .pipe(gulp.dest(packageDistribution));
+});
+
+/**
+ * This task wraps blocks_compressed.js into a CommonJS module for Node.js.
+ * This is an equivelant task to package-blockly but for Node.js.
+ * @example import 'blockly/blockly-node';
+ */
+gulp.task('package-blockly-node', function() {
+  // Override textToDomDocument, providing a Node.js alternative to DOMParser.
+  return gulp.src('blockly_compressed.js')
+    .pipe(gulp.insert.wrap(`
+    var self = global;`,
+      `if (typeof DOMParser !== 'function') {
+        var JSDOM = require('jsdom').JSDOM;
+        var window = (new JSDOM()).window;
+        var document = window.document;
+        var Element = window.Element;
+        Blockly.utils.xml.textToDomDocument = function(text) {
+          var jsdom = new JSDOM(text, { contentType: 'text/xml' });
+          return jsdom.window.document;
+        };
+      }`))
+    .pipe(packageCommonJS('Blockly', []))
+    .pipe(gulp.rename('blockly-node.js'))
+    .pipe(gulp.dest(packageDistribution));
+})
+
+/**
+ * This task wraps blocks_compressed.js into a UMD module.
+ * @example import 'blockly/blocks';
+ */
+gulp.task('package-blocks', function() {
+  return gulp.src('blocks_compressed.js')
+    .pipe(gulp.insert.prepend(`
+    Blockly.Blocks={};`))
+    .pipe(packageUMD('Blockly.Blocks', [{
+        name: 'Blockly',
+        amd: './core',
+        cjs: './core',
+      }]))
+    .pipe(gulp.rename('blocks.js'))
+    .pipe(gulp.dest(packageDistribution));
+});
+
+/**
+ * This task wraps package/index.js into a UMD module.
+ * We implicitly require the Node entry point in CommonJS environments,
+ * and the Browser entry point for AMD environments.
+ * @example import * as Blockly from 'blockly';
+ */
+gulp.task('package-index', function() {
+  return gulp.src('package/index.js')
+    .pipe(packageUMD('Blockly', [{
+        name: 'Blockly',
+        amd: './browser',
+        cjs: './node',
+      }]))
+    .pipe(gulp.rename('index.js'))
+    .pipe(gulp.dest(packageDistribution));
+});
+
+/**
+ * This task wraps package/browser/index.js into a UMD module.
+ * By default, the module includes Blockly core and built-in blocks,
+ * as well as the JavaScript code generator and the English block
+ * localization files.
+ * This module is configured (in package.json) to replaces the module
+ * built by package-node in browser environments.
+ * @example import * as Blockly from 'blockly/browser';
+ */
+gulp.task('package-browser', function() {
+  return gulp.src('package/browser/index.js')
+    .pipe(packageUMD('Blockly', [{
+        name: 'Blockly',
+        amd: './core-browser',
+        cjs: './core-browser',
+      },{
+        name: 'En',
+        amd: './msg/en',
+        cjs: './msg/en',
+      },{
+        name: 'BlocklyBlocks',
+        amd: './blocks',
+        cjs: './blocks',
+      },{
+        name: 'BlocklyJS',
+        amd: './javascript',
+        cjs: './javascript',
+      }]))
+    .pipe(gulp.rename('browser.js'))
+    .pipe(gulp.dest(packageDistribution));
+});
+
+/**
+ * This task wraps package/browser/core.js into a UMD module.
+ * By default, the module includes the Blockly core package and a
+ * helper method to set the locale.
+ * This module is configured (in package.json) to replaces the module
+ * built by package-node-core in browser environments.
+ * @example import * as Blockly from 'blockly/core';
+ */
+gulp.task('package-core', function() {
+  return gulp.src('package/browser/core.js')
+    .pipe(packageUMD('Blockly', [{
+        name: 'Blockly',
+        amd: './blockly',
+        cjs: './blockly',
+      }]))
+    .pipe(gulp.rename('core-browser.js'))
+    .pipe(gulp.dest(packageDistribution));
+});
+
+/**
+ * This task wraps package/node/index.js into a CommonJS module for Node.js.
+ * By default, the module includes Blockly core and built-in blocks,
+ * as well as all the code generators and the English block localization files.
+ * This module is configured (in package.json) to be replaced by the module
+ * built by package-browser in browser environments.
+ * @example import * as Blockly from 'blockly/node';
+ */
+gulp.task('package-node', function() {
+  return gulp.src('package/node/index.js')
+    .pipe(packageCommonJS('Blockly', [{
+        name: 'Blockly',
+        cjs: './core',
+      },{
+        name: 'En',
+        cjs: './msg/en',
+      },{
+        name: 'BlocklyBlocks',
+        cjs: './blocks',
+      },{
+        name: 'BlocklyJS',
+        cjs: './javascript',
+      },{
+        name: 'BlocklyPython',
+        cjs: './python',
+      },{
+        name: 'BlocklyPHP',
+        cjs: './php',
+      },{
+        name: 'BlocklyLua',
+        cjs: './lua',
+      }, {
+        name: 'BlocklyDart',
+        cjs: './dart',
+      }]))
+    .pipe(gulp.rename('node.js'))
+    .pipe(gulp.dest(packageDistribution));
+});
+
+/**
+ * This task wraps package/node/core.js into a CommonJS module for Node.js.
+ * By default, the module includes the Blockly core package for Node.js
+ * and a helper method to set the locale.
+ * This module is configured (in package.json) to be replaced by the module
+ * built by package-core in browser environments.
+ * @example import * as Blockly from 'blockly/core';
+ */
+gulp.task('package-node-core', function() {
+  return gulp.src('package/node/core.js')
+    .pipe(packageCommonJS('Blockly', [{
+        name: 'Blockly',
+        amd: './blockly-node',
+        cjs: './blockly-node',
+      }]))
+    .pipe(gulp.rename('core.js'))
+    .pipe(gulp.dest(packageDistribution));
+});
+
+/**
+ * A helper method for packaging a Blockly code generator into a UMD module.
+ * @param {string} file Source file name.
+ * @param {string} rename Destination file name.
+ * @param {string} generator Generator export namespace. 
+ */
+function packageGenerator(file, rename, generator) {
+  return gulp.src(file)
+    .pipe(packageUMD(generator, [{
+        name: 'Blockly',
+        amd: './core',
+        cjs: './core',
+      }]))
+    .pipe(gulp.rename(rename))
+    .pipe(gulp.dest(packageDistribution));
+};
+
+/**
+ * This task wraps javascript_compressed.js into a UMD module.
+ * @example import 'blockly/javascript';
+ */
+gulp.task('package-javascript', function() {
+  return packageGenerator('javascript_compressed.js', 'javascript.js', 'Blockly.JavaScript');
+});
+
+/**
+ * This task wraps python_compressed.js into a UMD module.
+ * @example import 'blockly/python';
+ */
+gulp.task('package-python', function() {
+  return packageGenerator('python_compressed.js', 'python.js', 'Blockly.Python');
+});
+
+/**
+ * This task wraps lua_compressed.js into a UMD module.
+ * @example import 'blockly/lua';
+ */
+gulp.task('package-lua', function() {
+  return packageGenerator('lua_compressed.js', 'lua.js', 'Blockly.Lua');
+});
+
+/**
+ * This task wraps dart_compressed.js into a UMD module.
+ * @example import 'blockly/dart';
+ */
+gulp.task('package-dart', function() {
+  return packageGenerator('dart_compressed.js', 'dart.js', 'Blockly.Dart');
+});
+
+/**
+ * This task wraps php_compressed.js into a UMD module.
+ * @example import 'blockly/php';
+ */
+gulp.task('package-php', function() {
+  return packageGenerator('php_compressed.js', 'php.js', 'Blockly.PHP');
+});
+
+/**
+ * This task wraps each of the msg/js/* files into a UMD module.
+ * @example import * as En from 'blockly/msg/en';
+ */
+gulp.task('package-locales', function() {
+  // Remove references to goog.provide and goog.require.
+  return gulp.src('msg/js/*.js')
+      .pipe(gulp.replace(/goog\.[^\n]+/g, ''))
+      .pipe(gulp.insert.prepend(`
+      var Blockly = {};Blockly.Msg={};`))
+      .pipe(packageUMD('Blockly.Msg', [{
+          name: 'Blockly',
+          amd: '../core',
+          cjs: '../core',
+        }]))
+      .pipe(gulp.dest(`${packageDistribution}/msg`));
+});
+
+/**
+ * This task creates a UMD bundle of Blockly which includes the Blockly
+ * core files, the built-in blocks, the JavaScript code generator and the
+ * English localization files.
+ * @example <script src="https://unpkg.com/blockly/blockly.min.js"></script>
+ */
+gulp.task('package-umd-bundle', function() {
+  var srcs = [
+    'blockly_compressed.js',
+    'msg/js/en.js',
+    'blocks_compressed.js',
+    'javascript_compressed.js'
+  ];
+  return gulp.src(srcs)
+    .pipe(gulp.concat('blockly.min.js'))
+    .pipe(packageUMD('Blockly', []))
+    .pipe(gulp.dest(`${packageDistribution}`))
+});
+
+/**
+ * This task copies all the media/* files into the distribution directory.
+ */
+gulp.task('package-media', function() {
+  return gulp.src('./media/*')
+    .pipe(gulp.dest(`${packageDistribution}/media`));
+});
+
+/**
+ * This task copies the package.json file into the distribution directory.
+ */
+gulp.task('package-json', function() {
+  return gulp.src('./package.json')
+    .pipe(gulp.dest(`${packageDistribution}`))
+});
+
+/**
+ * This task copies the package/README.md file into the distribution directory.
+ * This file is what developers will see at https://www.npmjs.com/package/blockly.
+ */
+gulp.task('package-readme', function() {
+  return gulp.src('./package/README.md')
+    .pipe(gulp.dest(`${packageDistribution}`))
+});
+
+/**
+ * This task copies the typings/blockly.d.ts TypeScript definition file into the
+ * distribution directory.
+ * The bundled declaration file is referenced in package.json in the types property.
+ */
+gulp.task('package-dts', function() {
+  return gulp.src('./typings/blockly.d.ts')
+    .pipe(gulp.dest(`${packageDistribution}`))
+});
+
+/**
+ * This task prepares the NPM distribution files under the /dist directory.
+ */
+gulp.task('package', gulp.parallel(
+  'package-index',
+  'package-browser',
+  'package-node',
+  'package-core',
+  'package-node-core',
+  'package-blockly',
+  'package-blockly-node',
+  'package-blocks',
+  'package-javascript',
+  'package-python',
+  'package-lua',
+  'package-dart',
+  'package-php',
+  'package-locales',
+  'package-media',
+  'package-umd-bundle',
+  'package-json',
+  'package-readme',
+  'package-dts'
+  ));
+
+// The release task prepares Blockly for an npm release.
+// It rebuilds the Blockly compressed files and updates the TypeScript
+// typings, and then packages all the npm release files into the /dist directory
+gulp.task('release', gulp.series(['build', /*'typings',*/ function() {
+  // Clean directory if exists
+  if (fs.existsSync(packageDistribution)) {
+    rimraf.sync(packageDistribution);
+  }
+  fs.mkdirSync(packageDistribution);
+}, 'package']));
 
 // The default task concatenates files for Node.js, using English language
 // blocks and the JavaScript generator.
-gulp.task('default', gulp.series(['build', 'blockly_javascript_en']));
+gulp.task('default', gulp.series(['build', 'blockly_node_javascript_en']));

package.json

@@ -2,7 +2,6 @@
   "name": "blockly",
   "version": "2.20190722.1",
   "description": "Blockly is a library for building visual programming editors.",
-  "main": "blockly_node_javascript_en.js",
   "keywords": [
     "blockly"
   ],
@@ -18,9 +17,20 @@
     "name": "Neil Fraser"
   },
   "scripts": {
-    "prepare": "gulp blockly_javascript_en",
+    "prepare": "gulp blockly_node_javascript_en",
     "lint": "eslint .",
-    "test": "tests/run_all_tests.sh"
+    "test": "tests/run_all_tests.sh",
+    "package": "gulp package",
+    "release": "gulp release"
+  },
+  "main": "./index.js",
+  "umd": "./blockly.min.js",
+  "unpkg": "./blockly.min.js",
+  "types": "./blockly.d.ts",
+  "browser": {
+    "./node.js": "./browser.js",
+    "./core.js": "./core-browser.js",
+    "./blockly-node.js": "./blockly.js"
   },
   "license": "Apache-2.0",
   "private": true,
@@ -34,9 +44,14 @@
     "gulp-insert": "^0.5.0",
     "gulp-series": "^1.0.2",
     "gulp-shell": "^0.7.1",
+    "gulp-rename": "^1.4.0",
+    "gulp-replace": "^1.0.0",
+    "gulp-umd": "^2.0.0",
     "jshint": "^2.10.2",
     "mocha": "^6.1.4",
-    "webdriverio": "^5.11.5"
+    "webdriverio": "^5.11.5",
+    "rimraf": "^2.6.3",
+    "typescript-closure-tools": "^0.0.7"
   },
   "jshintConfig": {
     "globalstrict": true,

package/README.md

@@ -0,0 +1,77 @@
+# Blockly
+
+Google's Blockly is a web-based, visual programming editor.  Users can drag
+blocks together to build programs.  All code is free and open source.
+
+The source for this module is in the [Blockly repo](http://github.com/google/blockly).
+
+## Installation
+
+You can install this package either via ``npm`` or ``unpkg``.
+
+### npm
+```bash
+npm install blockly
+```
+
+### unpkg
+```html
+<script src="https://unpkg.com/blockly/blockly.min.js"></script>
+```
+
+## Example Usage
+
+```js
+import Blockly from 'blockly';
+Blockly.inject('blocklyDiv', {
+    ...
+})
+```
+
+## Samples
+
+For samples on how to integrate Blockly into your project, view the list of samples at [blockly-samples](https://github.com/google/blockly-samples).
+
+
+### Importing Blockly
+
+When you import Blockly with ``import * as Blockly from 'blockly';`` you'll get the default modules:
+Blockly core, Blockly built-in blocks, the JavaScript generator and the English lang files. 
+
+If you need more flexibility, you'll want to define your imports more carefully: 
+
+#### Blockly Core
+
+```js
+import * as Blockly from 'blockly/core';
+```
+
+#### Blockly build in blocks
+
+```js
+import 'blockly/blocks';
+```
+
+#### Blockly Generators
+If your application needs to generate code from the Blockly blocks, you'll want to include a generator.
+
+```js
+import 'blockly/python';
+```
+to include the Python generator, you can also import ``blockly/js``, ``blockly/php``, ``blockly/dart`` and ``blockly/lua``.
+
+#### Blockly Languages
+
+```js
+import * as Fr from 'blockly/msg/fr';
+Blockly.setLocale(Fr);
+```
+
+To import the French lang files. Once you've imported the specific lang module, you'll also want to set the locale in Blockly.
+
+For a full list of supported Blockly locales, see: [https://github.com/google/blockly/tree/master/msg/js](https://github.com/google/blockly/tree/master/msg/js)
+
+
+## License
+
+Apache 2.0

package/browser/core.js

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Visual Blocks Editor
+ *
+ * Copyright 2019 Google Inc.
+ * https://developers.google.com/blockly/
+ *
+ * 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 Blockly core module for the browser. It includes blockly.js
+ *               and adds a helper method for setting the locale.
+ */
+
+/* eslint-disable */
+'use strict';
+
+// Add a helper method to set the Blockly locale.
+Blockly.setLocale = function(locale) {
+  Blockly.Msg = Object.assign(Blockly.Msg || {}, locale);
+};

package/browser/index.js

@@ -0,0 +1,35 @@
+/**
+ * @license
+ * Visual Blocks Editor
+ *
+ * Copyright 2019 Google Inc.
+ * https://developers.google.com/blockly/
+ *
+ * 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 Blockly module for the browser. This includes Blockly core
+ * and built in blocks, the JavaScript code generator and the English block
+ * localization files.
+ */
+
+/* eslint-disable */
+'use strict';
+
+// Include the EN Locale by default.
+Blockly.setLocale(En);
+
+Blockly.Blocks = Object.assign(Blockly.Blocks, BlocklyBlocks);
+
+Blockly.JavaScript = BlocklyJS;

package/index.js

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Visual Blocks Editor
+ *
+ * Copyright 2019 Google Inc.
+ * https://developers.google.com/blockly/
+ *
+ * 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 Blockly module.
+ */
+
+/* eslint-disable */
+'use strict';

package/node/core.js

@@ -0,0 +1,32 @@
+/**
+ * @license
+ * Visual Blocks Editor
+ *
+ * Copyright 2019 Google Inc.
+ * https://developers.google.com/blockly/
+ *
+ * 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 Blockly core module for Node. It includes blockly-node.js
+ *               and adds a helper method for setting the locale.
+ */
+
+/* eslint-disable */
+'use strict';
+
+// Add a helper method to set the Blockly locale.
+Blockly.setLocale = function(locale) {
+  Blockly.Msg = Object.assign(Blockly.Msg || {}, locale);
+};

package/node/index.js

@@ -0,0 +1,42 @@
+/**
+ * @license
+ * Visual Blocks Editor
+ *
+ * Copyright 2019 Google Inc.
+ * https://developers.google.com/blockly/
+ *
+ * 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 Blockly module for Node. It includes Blockly core,
+ *               built-in blocks, all the generators and the English locale.
+ */
+
+/* eslint-disable */
+'use strict';
+
+// Include the EN Locale by default.
+Blockly.setLocale(En);
+
+Blockly.Blocks = Object.assign(Blockly.Blocks, BlocklyBlocks);
+
+Blockly.JavaScript = BlocklyJS;
+
+Blockly.Python = BlocklyPython;
+
+Blockly.Lua = BlocklyLua;
+
+Blockly.PHP = BlocklyPHP;
+
+Blockly.Dart = BlocklyDart;

package/templates/node.template

@@ -0,0 +1,5 @@
+/* eslint-disable */
+(function (<%= param %>){
+<%= contents %>
+module.exports = <%= exports %>;
+})(<%= cjs %>); 

package/templates/umd.template

@@ -0,0 +1,13 @@
+/* eslint-disable */
+;(function(root, factory) {
+  if (typeof define === 'function' && define.amd) { // AMD
+    define(<%= amd %>, factory);
+  } else if (typeof exports === 'object') { // Node.js
+    module.exports = factory(<%= cjs %>);
+  } else { // Browser
+    root.<%= namespace %> = factory(<%= global %>);
+  }
+}(this, function(<%= param %>) {
+<%= contents %>
+return <%= exports %>;
+})); 

typings/README.md

@@ -0,0 +1,13 @@
+# blockly.d.ts
+
+This ``blockly.d.ts`` file describes the TypeScript type definitions for Blockly.
+If you consume Blockly through ``npm``, this file is already included in the ``npm`` package.
+Otherwise, you can include a copy of this file with your sources and reference it through a [Triple-Slash directive](https://www.typescriptlang.org/docs/handbook/triple-slash-directives.html).
+
+
+## Generating a new version
+
+To generate a new version of the Typings file, from the Blockly root directory run ``npm run typings``.
+You will need to run ``npm install`` for this to work.
+
+Note: In order to check for errors in the typings file, run ``tsc`` in the ``typings/`` directory.

typings/parts/blockly-header.d.ts

@@ -0,0 +1,26 @@
+/**
+ * @license
+ * Visual Blocks Editor
+ *
+ * Copyright 2019 Google Inc.
+ * https://developers.google.com/blockly/
+ *
+ * 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 Type definitions for Blockly.
+ * @author samelh@google.com (Sam El-Husseini)
+ */
+
+export = Blockly;

typings/parts/blockly-interfaces.d.ts

@@ -0,0 +1,59 @@
+
+declare module Blockly {
+
+  interface BlocklyOptions {
+    toolbox?: HTMLElement | string;
+    readOnly?: boolean;
+    trashcan?: boolean;
+    maxTrashcanContents?: number;
+    collapse?: boolean;
+    comments?: boolean;
+    disable?: boolean;
+    sounds?: boolean;
+    rtl?: boolean;
+    horizontalLayout?: boolean;
+    toolboxPosition?: string;
+    css?: boolean;
+    oneBasedIndex?: boolean;
+    media?: string;
+    theme?: Blockly.BlocklyTheme;
+    move?: {
+      scrollbars?: boolean;
+      drag?: boolean;
+      wheel?: boolean;
+    };
+    grid?: {
+      spacing?: number;
+      colour?: string;
+      length?: number;
+      snap?: boolean;
+    };
+    zoom?: {
+      controls?: boolean;
+      wheel?: boolean;
+      startScale?: number;
+      maxScale?: number;
+      minScale?: number;
+      scaleSpeed?: number;
+    };
+  }
+
+  interface BlocklyTheme {
+    defaultBlockStyles?: {[blocks: string]: Blockly.Theme.BlockStyle;};
+    categoryStyles?: {[category: string]: Blockly.Theme.CategoryStyle;};
+  }
+
+  interface Metrics {
+    absoluteLeft: number;
+    absoluteTop: number;
+    contentHeight: number;
+    contentLeft: number;
+    contentTop: number;
+    contentWidth: number;
+    viewHeight: number;
+    viewLeft: number;
+    viewTop: number;
+    viewWidth: number;
+  }
+
+}

typings/parts/goog-closure.d.ts

@@ -0,0 +1,402 @@
+declare namespace goog {
+  function require(name: string): void;
+  function provide(name: string): void;
+  function isFunction(f: any): boolean;
+  function isString(s: any): boolean;
+
+  class Disposable {
+    dispose(): void;
+  }
+
+  namespace dom {
+    function createDom(tagName: string, opt_attributes?: Object, ...var_args: Object[]): Element;
+    function createDom(name: string, ns?: string, children?: any): HTMLElement;
+    function removeChildren(el: Element): void;
+    function removeNode(node: Node): void;
+    function getViewportSize(): any;
+
+    namespace classlist {
+      function add(el: Element, className: string): void;
+    }
+
+    class DomHelper {
+    }
+  }
+
+  namespace ui {
+    class Control extends Component {
+      getChildCount(): number;
+      getContent(): string | Node | Array<Node>;
+      getContentElement(): Element;
+      setChecked(checked: boolean): void;
+      setContent(content: string | Node | Array<Node>): void;
+      setVisible(visible: boolean, opt_force?: boolean): boolean;
+    }
+    class Component {
+      static EventType: {
+        BEFORE_SHOW: string;
+        SHOW: string;
+        HIDE: string;
+        DISABLE: string;
+        ENABLE: string;
+        HIGHLIGHT: string;
+        UNHIGHLIGHT: string;
+        ACTIVATE: string;
+        DEACTIVATE: string;
+        SELECT: string;
+        UNSELECT: string;
+        CHECK: string;
+        UNCHECK: string;
+        FOCUS: string;
+        BLUR: string;
+        OPEN: string;
+        CLOSE: string;
+        ENTER: string;
+        LEAVE: string;
+        ACTION: string;
+        CHANGE: string;
+      };
+      getHandler<T>(): events.EventHandler<T>;
+      getElement(): Element;
+      render(opt_parentElement?: Element): void;
+      setId(id: string): void;
+      setRightToLeft(rightToLeft: boolean): void;
+      addChild(child: Component, opt_render?: boolean): void;
+      getChildAt(index: number): Component;
+      removeChildren(opt_unrender: boolean): void;
+    }
+    class Container extends Component {
+    }
+    class Menu extends Container implements events.Listenable {
+      listen: () => events.ListenableKey;
+      setAllowAutoFocus(allow: boolean): void;
+    }
+    class MenuItem extends Control {
+      constructor(content: (string | Node));
+      setCheckable(checkable: boolean): void;
+      setValue(value: any): void;
+      getValue(): any;
+      addClassName(className: string): void;
+    }
+    class DatePicker extends Component {
+
+    }
+  }
+
+  namespace ui.tree {
+    class BaseNode {
+    }
+    class TreeControl__Class {
+    }
+    class TreeNode__Class {
+    }
+  }
+
+  namespace events {
+    function listen(eventSource: Element | Listenable, eventType: EventType, listener: any, capturePhase?: boolean, handler?: Object): void;
+    function unlistenByKey(key: any): void;
+    interface ListenableKey {
+      key: number;
+    }
+    interface Listenable {
+      listen: () => ListenableKey;
+    }
+    type EventType = string;
+    let EventType: {
+      CLICK: EventType;
+      RIGHTCLICK: EventType;
+      DBLCLICK: EventType;
+      MOUSEDOWN: EventType;
+      MOUSEUP: EventType;
+      MOUSEOVER: EventType;
+      MOUSEOUT: EventType;
+      MOUSEMOVE: EventType;
+      MOUSEENTER: EventType;
+      MOUSELEAVE: EventType;
+      SELECTSTART: EventType;
+      WHEEL: EventType;
+      KEYPRESS: EventType;
+      KEYDOWN: EventType;
+      KEYUP: EventType;
+      BLUR: EventType;
+      FOCUS: EventType;
+      DEACTIVATE: EventType;
+      FOCUSIN: EventType;
+      FOCUSOUT: EventType;
+      CHANGE: EventType;
+      SELECT: EventType;
+      SUBMIT: EventType;
+      INPUT: EventType;
+      PROPERTYCHANGE: EventType;
+      DRAGSTART: EventType;
+      DRAG: EventType;
+      DRAGENTER: EventType;
+      DRAGOVER: EventType;
+      DRAGLEAVE: EventType;
+      DROP: EventType;
+      DRAGEND: EventType;
+      TOUCHSTART: EventType;
+      TOUCHMOVE: EventType;
+      TOUCHEND: EventType;
+      TOUCHCANCEL: EventType;
+      BEFOREUNLOAD: EventType;
+      CONSOLEMESSAGE: EventType;
+      CONTEXTMENU: EventType;
+      DOMCONTENTLOADED: EventType;
+      ERROR: EventType;
+      HELP: EventType;
+      LOAD: EventType;
+      LOSECAPTURE: EventType;
+      ORIENTATIONCHANGE: EventType;
+      READYSTATECHANGE: EventType;
+      RESIZE: EventType;
+      SCROLL: EventType;
+      UNLOAD: EventType;
+      HASHCHANGE: EventType;
+      PAGEHIDE: EventType;
+      PAGESHOW: EventType;
+      POPSTATE: EventType;
+      COPY: EventType;
+      PASTE: EventType;
+      CUT: EventType;
+      BEFORECOPY: EventType;
+      BEFORECUT: EventType;
+      BEFOREPASTE: EventType;
+      ONLINE: EventType;
+      OFFLINE: EventType;
+      MESSAGE: EventType;
+      CONNECT: EventType;
+      ANIMATIONSTART: EventType;
+      ANIMATIONEND: EventType;
+      ANIMATIONITERATION: EventType;
+      TRANSITIONEND: EventType;
+      POINTERDOWN: EventType;
+      POINTERUP: EventType;
+      POINTERCANCEL: EventType;
+      POINTERMOVE: EventType;
+      POINTEROVER: EventType;
+      POINTEROUT: EventType;
+      POINTERENTER: EventType;
+      POINTERLEAVE: EventType;
+      GOTPOINTERCAPTURE: EventType;
+      LOSTPOINTERCAPTURE: EventType;
+      MSGESTURECHANGE: EventType;
+      MSGESTUREEND: EventType;
+      MSGESTUREHOLD: EventType;
+      MSGESTURESTART: EventType;
+      MSGESTURETAP: EventType;
+      MSGOTPOINTERCAPTURE: EventType;
+      MSINERTIASTART: EventType;
+      MSLOSTPOINTERCAPTURE: EventType;
+      MSPOINTERCANCEL: EventType;
+      MSPOINTERDOWN: EventType;
+      MSPOINTERENTER: EventType;
+      MSPOINTERHOVER: EventType;
+      MSPOINTERLEAVE: EventType;
+      MSPOINTERMOVE: EventType;
+      MSPOINTEROUT: EventType;
+      MSPOINTEROVER: EventType;
+      MSPOINTERUP: EventType;
+      TEXT: EventType;
+      TEXTINPUT: EventType;
+      COMPOSITIONSTART: EventType;
+      COMPOSITIONUPDATE: EventType;
+      COMPOSITIONEND: EventType;
+      EXIT: EventType;
+      LOADABORT: EventType;
+      LOADCOMMIT: EventType;
+      LOADREDIRECT: EventType;
+      LOADSTART: EventType;
+      LOADSTOP: EventType;
+      RESPONSIVE: EventType;
+      SIZECHANGED: EventType;
+      UNRESPONSIVE: EventType;
+      VISIBILITYCHANGE: EventType;
+      STORAGE: EventType;
+      DOMSUBTREEMODIFIED: EventType;
+      DOMNODEINSERTED: EventType;
+      DOMNODEREMOVED: EventType;
+      DOMNODEREMOVEDFROMDOCUMENT: EventType;
+      DOMNODEINSERTEDINTODOCUMENT: EventType;
+      DOMATTRMODIFIED: EventType;
+      DOMCHARACTERDATAMODIFIED: EventType;
+    };
+    let KeyCodes: {
+      A: number,
+      ALT: number,
+      APOSTROPHE: number,
+      AT_SIGN: number,
+      B: number,
+      BACKSLASH: number,
+      BACKSPACE: number,
+      C: number,
+      CAPS_LOCK: number,
+      CLOSE_SQUARE_BRACKET: number,
+      COMMA: number,
+      CONTEXT_MENU: number,
+      CTRL: number,
+      D: number,
+      DASH: number,
+      DELETE: number,
+      DOWN: number,
+      E: number,
+      EIGHT: number,
+      END: number,
+      ENTER: number,
+      EQUALS: number,
+      ESC: number,
+      F: number,
+      F1: number,
+      F10: number,
+      F11: number,
+      F12: number,
+      F2: number,
+      F3: number,
+      F4: number,
+      F5: number,
+      F6: number,
+      F7: number,
+      F8: number,
+      F9: number,
+      FF_DASH: number,
+      FF_EQUALS: number,
+      FF_SEMICOLON: number,
+      FIRST_MEDIA_KEY: number,
+      FIVE: number,
+      FOUR: number,
+      G: number,
+      H: number,
+      HOME: number,
+      I: number,
+      INSERT: number,
+      J: number,
+      K: number,
+      L: number,
+      LAST_MEDIA_KEY: number,
+      LEFT: number,
+      M: number,
+      MAC_ENTER: number,
+      MAC_FF_META: number,
+      MAC_WK_CMD_LEFT: number,
+      MAC_WK_CMD_RIGHT: number,
+      META: number,
+      N: number,
+      NINE: number,
+      NUMLOCK: number,
+      NUM_CENTER: number,
+      NUM_DIVISION: number,
+      NUM_EIGHT: number,
+      NUM_FIVE: number,
+      NUM_FOUR: number,
+      NUM_MINUS: number,
+      NUM_MULTIPLY: number,
+      NUM_NINE: number,
+      NUM_ONE: number,
+      NUM_PERIOD: number,
+      NUM_PLUS: number,
+      NUM_SEVEN: number,
+      NUM_SIX: number,
+      NUM_THREE: number,
+      NUM_TWO: number,
+      NUM_ZERO: number,
+      O: number,
+      ONE: number,
+      OPEN_SQUARE_BRACKET: number,
+      P: number,
+      PAGE_DOWN: number,
+      PAGE_UP: number,
+      PAUSE: number,
+      PERIOD: number,
+      PHANTOM: number,
+      PLUS_SIGN: number,
+      PRINT_SCREEN: number,
+      Q: number,
+      QUESTION_MARK: number,
+      R: number,
+      RIGHT: number,
+      S: number,
+      SCROLL_LOCK: number,
+      SEMICOLON: number,
+      SEVEN: number,
+      SHIFT: number,
+      SINGLE_QUOTE: number,
+      SIX: number,
+      SLASH: number,
+      SPACE: number,
+      T: number,
+      TAB: number,
+      THREE: number,
+      TILDE: number,
+      TWO: number,
+      U: number,
+      UP: number,
+      V: number,
+      VK_NONAME: number,
+      W: number,
+      WIN_IME: number,
+      WIN_KEY: number,
+      WIN_KEY_FF_LINUX: number,
+      WIN_KEY_RIGHT: number,
+      X: number,
+      Y: number,
+      Z: number,
+      ZERO: number
+    }
+    class EventTarget extends Disposable {
+    }
+    class EventHandler<T> {
+      handleEvent(e: any): void;
+      listen(src: Element | Listenable, type: string, opt_fn?: any): EventHandler<T>;
+    }
+
+    /**
+    * Accepts a browser event object and creates a patched, cross browser event
+    * object.
+    * The content of this object will not be initialized if no event object is
+    * provided. If this is the case, init() needs to be invoked separately.
+    * @param {Event=} opt_e Browser event object.
+    * @param {EventTarget=} opt_currentTarget Current target for event.
+    */
+    class BrowserEvent {
+      constructor(opt_e?: Event, opt_currentTarget?: EventTarget);
+    }
+  }
+  namespace userAgent {
+    /**
+     * Whether the user agent is running on a mobile device.
+     *
+     * TODO(nnaze): Consider deprecating MOBILE when labs.userAgent
+     *   is promoted as the gecko/webkit logic is likely inaccurate.
+     *
+     * @type {boolean}
+     */
+    var MOBILE: boolean;
+
+    /**
+     * Whether the user agent is running on Android.
+     * @type {boolean}
+     */
+    var ANDROID: boolean;
+
+    /**
+     * Whether the user agent is running on an iPhone.
+     * @type {boolean}
+     */
+    var IPHONE: boolean;
+
+    /**
+     * Whether the user agent is running on an iPad.
+     * @type {boolean}
+     */
+    var IPAD: boolean;
+  }
+  namespace html {
+    class SafeHtml {
+    }
+  }
+  namespace positioning {
+    class ClientPosition {
+      constructor(x: number, y: number);
+    }
+  }
+}

typings/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "compilerOptions": {
+      "module": "commonjs",
+      "lib": [
+          "dom",
+          "es6"
+      ],
+      "noImplicitAny": true,
+      "noImplicitThis": true,
+      "strictNullChecks": false,
+      "strictFunctionTypes": true,
+      "baseUrl": "../",
+      "typeRoots": [
+          "../node_modules/@types"
+      ],
+      "types": [],
+      "noEmit": true,
+      "forceConsistentCasingInFileNames": true
+  },
+  "files": [
+      "blockly.d.ts"
+  ]
+}