HPCC-11761 Cleanup EclWatch build profile

Handle non AMD files specifically.
Merge run.js into main profile.
Add "hpcc" layer that includes initial EclWatch pages (to improve initial load
performance).

Fixes HPCC-11761

Signed-off-by: Gordon Smith <gordon.smith@lexisnexis.com>

esp/build.sh

@@ -14,12 +14,6 @@ TOOLSDIR="$SRCDIR/util/buildscripts"
 # Destination directory for built code
 DISTDIR=$1
 
-# Module ID of the main application package loader configuration
-LOADERMID="eclwatch/run"
-
-# Main application package loader configuration
-LOADERCONF="$SRCDIR/$LOADERMID.js"
-
 # Main application package build configuration
 PROFILE="$BASEDIR/profiles/eclwatch.profile.js"
 
@@ -43,16 +37,14 @@ cp -r "$SRCDIR/CodeMirror2" "$DISTDIR/CodeMirror2"
 cat "$SRCDIR/stub.htm" | tr '\n' ' ' | \
 perl -pe "
   s/<\!--.*?-->//g;                          # Strip comments
-#  s/isDebug: *1/deps:['$LOADERMID']/;        # Remove isDebug, add deps
-#  s/<script src=\"$LOADERMID.*?\/script>//;  # Remove script eclwatch/run
   s/\s+/ /g;                                 # Collapse white-space" > "$DISTDIR/stub.htm"
 
 cd "$TOOLSDIR"
 
 if which node >/dev/null; then
-    node ../../dojo/dojo.js load=build --require "$LOADERCONF" --profile "$PROFILE" --releaseDir "$DISTDIR" ${*:2}
+    node ../../dojo/dojo.js load=build --require "$PROFILE" --releaseDir "$DISTDIR" ${*:2}
 elif which java >/dev/null; then
-    java -Xms256m -Xmx256m  -cp ../shrinksafe/js.jar:../closureCompiler/compiler.jar:../shrinksafe/shrinksafe.jar org.mozilla.javascript.tools.shell.Main  ../../dojo/dojo.js baseUrl=../../dojo load=build --require "$LOADERCONF" --profile "$PROFILE" --releaseDir "$DISTDIR" ${*:2}
+    java -Xms256m -Xmx256m  -cp ../shrinksafe/js.jar:../closureCompiler/compiler.jar:../shrinksafe/shrinksafe.jar org.mozilla.javascript.tools.shell.Main  ../../dojo/dojo.js baseUrl=../../dojo load=build --profile "$PROFILE" --releaseDir "$DISTDIR" ${*:2}
 else
     echo "Need node.js or Java to build!"
     exit 1
@@ -62,8 +54,6 @@ echo "Build complete"
 
 cd "$BASEDIR"
 
-LOADERMID=${LOADERMID//\//\\\/}
-
 for dojodir in dojo dojox dijit
 do
   for f in  $(find ${DISTDIR}/${dojo_dir} -type f -perm /a+x ! -name "*.sh" \

esp/profiles/eclwatch.profile.js

@@ -1,107 +1,98 @@
-/**
- * This is the default application build profile used by the boilerplate. While it looks similar, this build profile
- * is different from the package build profile at `app/package.js` in the following ways:
- *
- * 1. you can have multiple application build profiles (e.g. one for desktop, one for tablet, etc.), but only one
- *    package build profile;
- * 2. the package build profile only configures the `resourceTags` for the files in the package, whereas the
- *    application build profile tells the build system how to build the entire application.
- *
- * Look to `util/build/buildControlDefault.js` for more information on available options and their default values.
- */
-
 var profile = {
-    // `basePath` is relative to the directory containing this profile file; in this case, it is being set to the
-    // src/ directory, which is the same place as the `baseUrl` directory in the loader configuration. (If you change
-    // this, you will also need to update run.js.)
-    basePath: '../src/',
-
-    // This is the directory within the release directory where built packages will be placed. The release directory
-    // itself is defined by `build.sh`. You should probably not use this; it is a legacy option dating back to Dojo
-    // 0.4.
-    // If you do use this, you will need to update build.sh, too.
-    // releaseName: '',
-
-    // Builds a new release.
-    action: 'release',
-
-    // Strips all comments and whitespace from CSS files and inlines @imports where possible.
-    cssOptimize: 'comments',
-
-    // Excludes tests, demos, and original template files from being included in the built version.
+    basePath: "../src/",
+    action: "release",
+    layerOptimize: "closure",
+    optimize: "closure",
+    cssOptimize: "comments",
     mini: true,
-
-    // Uses Closure Compiler as the JavaScript minifier. This can also be set to "shrinksafe" to use ShrinkSafe,
-    // though ShrinkSafe is deprecated and not recommended.
-    // This option defaults to "" (no compression) if not provided.
-    optimize: 'closure',
-
-    // We're building layers, so we need to set the minifier to use for those, too.
-    // This defaults to "shrinksafe" if not provided.
-    layerOptimize: 'closure',
-
-    // Strips all calls to console functions within the code. You can also set this to "warn" to strip everything
-    // but console.error, and any other truthy value to strip everything but console.warn and console.error.
-    // This defaults to "normal" (strip all but warn and error) if not provided.
-    stripConsole: 'all',
-
-    // The default selector engine is not included by default in a dojo.js build in order to make mobile builds
-    // smaller. We add it back here to avoid that extra HTTP request. There is also a "lite" selector available; if
-    // you use that, you will need to set the `selectorEngine` property in `app/run.js`, too. (The "lite" engine is
-    // only suitable if you are not supporting IE7 and earlier.)
-    selectorEngine: 'acme',
-
-    // Builds can be split into multiple different JavaScript files called "layers". This allows applications to
-    // defer loading large sections of code until they are actually required while still allowing multiple modules to
-    // be compiled into a single file.
-    layers: {
-        // This is the main loader module. It is a little special because it is treated like an AMD module even though
-        // it is actually just plain JavaScript. There is some extra magic in the build system specifically for this
-        // module ID.
-        'dojo/dojo': {
-            // In addition to the loader `dojo/dojo` and the loader configuration file `app/run`, we are also including
-            // the main application `app/main` and the `dojo/i18n` and `dojo/domReady` modules because, while they are
-            // all conditional dependencies in `app/main`, we do not want to have to make extra HTTP requests for such
-            // tiny files.
-            include: [ 'dojo/i18n', 'dojo/domReady', 'hpcc/stub' ],
-
-            // By default, the build system will try to include `dojo/main` in the built `dojo/dojo` layer, which adds
-            // a bunch of stuff we do not want or need. We want the initial script load to be as small and quick to
-            // load as possible, so we configure it as a custom, bootable base.
-            boot: true,
-            customBase: true
-        }//,
-
-        // In the demo application, we conditionally require `app/Dialog` on the client-side, so here we build a
-        // separate layer containing just that client-side code. (Practically speaking, you would probably just want
-        // to roll everything into a single layer, but this helps provide a basic illustration of multi-layer builds.)
-        // Note that when you create a new layer, the module referenced by the layer is always included in the layer
-        // (in this case, `app/Dialog`), so it does not need to be explicitly defined in the `include` array.
-        //'hpcc/Dialog': {}
+    stripConsole: "all",
+    selectorEngine: "lite",
+    
+    defaultConfig: {
+        hasCache: {
+            "dojo-built": 1,
+            "dojo-loader": 1,
+            "dom": 1,
+            "host-browser": 1,
+            "config-selectorEngine": "lite"
+        },
+        async: 1
     },
 
-    // Providing hints to the build system allows code to be conditionally removed on a more granular level than
-    // simple module dependencies can allow. This is especially useful for creating tiny mobile builds.
-    // Keep in mind that dead code removal only happens in minifiers that support it! Currently, only Closure Compiler
-    // to the Dojo build system with dead code removal.
-    // A documented list of has-flags in use within the toolkit can be found at
-    // <http://dojotoolkit.org/reference-guide/dojo/has.html>.
     staticHasFeatures: {
-        // The trace & log APIs are used for debugging the loader, so we do not need them in the build.
-        'dojo-trace-api': 0,
-        'dojo-log-api': 0,
-
-        // This causes normally private loader data to be exposed for debugging. In a release build, we do not need
-        // that either.
-        'dojo-publish-privates': 0,
-
-        // This application is pure AMD, so get rid of the legacy loader.
-        'dojo-sync-loader': 0,
-
-        // `dojo-xhr-factory` relies on `dojo-sync-loader`, which we have removed.
-        'dojo-xhr-factory': 0,
+        "config-deferredInstrumentation": 0,
+        "config-dojo-loader-catches": 0,
+        "config-tlmSiblingOfDojo": 0,
+        "dojo-amd-factory-scan": 0,
+        "dojo-combo-api": 0,
+        "dojo-config-api": 1,
+        "dojo-config-require": 0,
+        "dojo-debug-messages": 0,
+        "dojo-dom-ready-api": 1,
+        "dojo-firebug": 0,
+        "dojo-guarantee-console": 1,
+        "dojo-has-api": 1,
+        "dojo-inject-api": 1,
+        "dojo-loader": 1,
+        "dojo-log-api": 0,
+        "dojo-modulePaths": 0,
+        "dojo-moduleUrl": 0,
+        "dojo-publish-privates": 0,
+        "dojo-requirejs-api": 0,
+        "dojo-sniff": 1,
+        "dojo-sync-loader": 0,
+        "dojo-test-sniff": 0,
+        "dojo-timeout-api": 0,
+        "dojo-trace-api": 0,
+        "dojo-undef-api": 0,
+        "dojo-v1x-i18n-Api": 1,
+        "dom": 1,
+        "host-browser": 1,
+        "extend-dojo": 1
+    },
 
-        // We are not loading tests in production, so we can get rid of some test sniffing code.
-        'dojo-test-sniff': 0
+    packages: [
+        'dojo',
+        'dijit',
+        'dojox',
+        'dgrid',
+        'put-selector',
+        'xstyle',
+        {
+            name: "d3",
+            location: "./d3",
+            trees: [
+                [".", ".", /(\/\.)|(~$)|(^((?!d3\.js).)*$)|(test|src|lib|bin)/]
+            ]
+        },
+        {
+            name: "topojson",
+            location: "./topojson",
+            trees: [
+                [".", ".", /(\/\.)|(~$)|(^((?!topojson\.js).)*$)|(test|examples|lib|bin)/]
+            ]
+        },
+        {
+            name: "hpcc",
+            location: "./eclwatch"
+        },
+        {
+            name: "templates",
+            location: "eclwatch/templates"
+        }
+    ],
+        
+    layers: {
+        "hpcc/hpcc": {
+            include: [ 
+                "hpcc/stub",
+                "hpcc/HPCCPlatformWidget",
+                "hpcc/ActivityWidget",
+                "hpcc/HPCCPlatformECLWidget",
+                "hpcc/WUQueryWidget"
+            ],
+            customBase: true,
+            boot: true
+        }
     }
 };

esp/src/eclwatch/run.js

@@ -1,42 +0,0 @@
-/**
- * This file is used to reconfigure parts of the loader at runtime for this application. We've put this extra
- * configuration in a separate file, instead of adding it directly to index.html, because it contains options that
- * can be shared if the application is run on both the client and the server.
- *
- * If you aren't planning on running your app on both the client and the server, you could easily move this
- * configuration into index.html (as a dojoConfig object) if it makes your life easier.
- */
-require({
-    // The base path for all packages and modules. If you don't provide this, baseUrl defaults to the directory
-    // that contains dojo.js. Since all packages are in the root, we just leave it blank. (If you change this, you
-    // will also need to update `app.profile.js`).
-    baseUrl: '',
-
-    // A list of packages to register. Strictly speaking, you do not need to register any packages,
-    // but you can't require "app" and get app/main.js if you do not register the "app" package (the loader will look
-    // for a module at <baseUrl>/app.js instead). Unregistered packages also cannot use the `map` feature, which
-    // might be important to you if you need to relocate dependencies. TL;DR, register all your packages all the time:
-    // it will make your life easier.
-    packages: [
-        // If you are registering a package that has an identical name and location, you can just pass a string
-        // instead, and it will configure it using that string for both the "name" and "location" properties. Handy!
-        'dojo',
-        'dijit',
-        'dojox',
-        'dgrid',
-        'put-selector',
-        'xstyle',
-        'd3',
-        'topojson',
-
-        {
-            name: "hpcc",
-            location: "eclwatch"
-        },
-        {
-            name: "templates",
-            location: "eclwatch/templates"
-        }
-    ]
-// Require `app`. This loads the main application module, `app/main`, since we registered the `app` package above.
-});

esp/src/eclwatch/stub.js

@@ -18,23 +18,23 @@ define([
     "dojo/dom",
     "dojo/dom-style",
     "dojo/io-query",
-    "dojo/ready"
-], function (fx, dom, domStyle, ioQuery, ready) {
+    "dojo/ready",
+    "dojo/_base/lang",
+    "dojo/_base/array",
+    "dojo/topic",
+
+    "dojox/html/entities",
+    "dojox/widget/Toaster"
+], function (fx, dom, domStyle, ioQuery, ready, lang, arrayUtil, topic,
+            entities, Toaster) {
 
     var initUi = function () {
         var params = ioQuery.queryToObject(dojo.doc.location.search.substr((dojo.doc.location.search.substr(0, 1) == "?" ? 1 : 0)));
         var hpccWidget = params.Widget ? params.Widget : "HPCCPlatformWidget";
 
         require([
-                "dojo/_base/lang",
-                "dojo/_base/array",
-                "dojo/topic",
-                "dojox/html/entities",
-                "dojox/widget/Toaster",
                 "hpcc/" + hpccWidget
-        ], function (lang, arrayUtil, topic,
-            entities, Toaster,
-            WidgetClass) {
+        ], function (WidgetClass) {
                 var webParams = {
                     id: "stub",
                     "class": "hpccApp"

esp/src/stub.htm

@@ -40,6 +40,7 @@
     <!-- load dojo and provide config via dojoConfig global -->
     <script src="/esp/files/eclwatch/dojoConfig.js"></script>
     <script src="/esp/files/dojo/dojo.js"></script>
+    <script src="/esp/files/eclwatch/hpcc.js"></script>
     <script>
         require(["hpcc/stub"], function (stub) {
             stub.init();