rbbt-rest 1.8.126 → 1.8.129

data/share/views/public/plugins/semantic-ui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "semantic-ui",
-  "version": "2.4.1",
+  "version": "2.2.12",
   "title": "Semantic UI",
   "description": "Semantic empowers designers and developers by creating a shared vocabulary for UI.",
   "homepage": "http://www.semantic-ui.com",
@@ -41,9 +41,9 @@
     "gulp-replace": "*",
     "gulp-rtlcss": "*",
     "gulp-uglify": "*",
+    "gulp-util": "*",
     "gulp-watch": "*",
     "map-stream": "*",
-    "replace-ext": "*",
     "require-dot-file": "*",
     "run-sequence": "*",
     "yamljs": "*"
@@ -51,38 +51,38 @@
   "dependencies": {
     "better-console": "*",
     "del": "^3.0.0",
-    "extend": "^3.0.2",
+    "extend": "^3.0.1",
     "gulp": "^3.9.1",
-    "gulp-autoprefixer": "^6.0.0",
+    "gulp-autoprefixer": "^4.0.0",
     "gulp-chmod": "^2.0.0",
-    "gulp-clone": "^2.0.1",
+    "gulp-clone": "^1.0.0",
     "gulp-concat": "^2.6.1",
-    "gulp-concat-css": "^3.1.0",
-    "gulp-copy": "4.0.1",
+    "gulp-concat-css": "^2.3.0",
+    "gulp-copy": "1.0.0",
     "gulp-dedupe": "0.0.2",
-    "gulp-flatten": "^0.4.0",
-    "gulp-header": "^2.0.5",
+    "gulp-flatten": "^0.3.1",
+    "gulp-header": "^1.8.8",
     "gulp-help": "^1.6.1",
     "gulp-if": "^2.0.2",
-    "gulp-json-editor": "^2.4.2",
-    "gulp-less": "^4.0.1",
-    "gulp-clean-css": "^3.10.0",
-    "gulp-notify": "^3.2.0",
-    "gulp-plumber": "^1.2.0",
-    "gulp-print": "^5.0.0",
-    "prompt-sui": "^3.2.1",
-    "gulp-rename": "^1.4.0",
-    "gulp-replace": "^1.0.0",
-    "gulp-rtlcss": "^1.3.0",
-    "gulp-uglify": "^3.0.1",
-    "gulp-watch": "^5.0.1",
-    "jquery": "^3.3.1",
+    "gulp-json-editor": "^2.2.1",
+    "gulp-less": "^3.3.2",
+    "gulp-clean-css": "^3.5.0",
+    "gulp-notify": "^3.0.0",
+    "gulp-plumber": "^1.1.0",
+    "gulp-print": "^2.0.1",
+    "gulp-prompt": "^0.2.0",
+    "gulp-rename": "^1.2.2",
+    "gulp-replace": "^0.6.1",
+    "gulp-rtlcss": "^1.0.0",
+    "gulp-uglify": "^3.0.0",
+    "gulp-util": "^3.0.8",
+    "gulp-watch": "^4.3.11",
+    "jquery": "^3.2.1",
     "map-stream": "^0.1.0",
     "merge-stream": "^1.0.0",
     "mkdirp": "^0.5.1",
     "require-dot-file": "^0.4.0",
-    "replace-ext": "^1.0.0",
-    "run-sequence": "^2.2.1",
+    "run-sequence": "^2.0.0",
     "wrench-sui": "^0.0.3",
     "yamljs": "^0.3.0"
   },

data/share/views/public/plugins/semantic-ui/src/README.md

@@ -3,7 +3,6 @@
 ### Built-In Tools
 
 From the Semantic directory you can setup gulp to build Semantic by running.
-
 ```bash
 npm install
 ```
@@ -11,12 +10,11 @@ npm install
 Semantic will automatically configure itself using a `post-install` script built into the package.
 
 After set-up can use gulp to build your project's css:
-
 ```bash
-# Watch files
+/* Watch files */
 gulp watch
 
-# Build all files
+/* Build all files */
 gulp build
 ```
 
@@ -29,8 +27,9 @@ Visit the [Getting Started Guide](http://learnsemantic.com/guide/expert.html) fo
 Each gulp task can be imported into your own Gulpfile using `require`
 
 ```javascript
-const watch = require('path/to/semantic/tasks/watch');
-
+var
+  watch = require('path/to/semantic/tasks/watch')
+;
 gulp.task('watch ui', 'Watch Semantic UI', watch));
 ```
 
@@ -41,14 +40,12 @@ gulp.task('watch ui', 'Watch Semantic UI', watch));
 Before using source files you will need to create a `theme.config` by renaming `theme.config.example`, and a site folder by renaming `_site/` to `site/`
 
 You can then import Semantic from your own LESS files:
-
 ```less
 /* Import all components */
 @import 'src/semantic';
 ```
 
 To import individual components you will have to create a scope for each import using `& {}`
-
 ```less
 /* Import a specific component */
 & { @import 'src/definitions/elements/button'; }
@@ -64,6 +61,7 @@ filename | usage | Initial Name
 **site/** | folder storing all your site's variables and css overrides for each UI component | _site/
 **semantic.json** | stores folder paths for build tools and current installed version for updates. Only necessary when using build tools | semantic.json.example
 
+
 ### Workflow
 
 You will only need to use Semantic's build tools while refining your UI. When designing pages, you can rely on the compiled css packages in  `dist/`.
@@ -121,9 +119,9 @@ You may also specify your own custom LESS in `site/elements/button.overrides`. T
 You can modify `theme.config` to use any prepackaged theme available in `src/themes/`.
 
 For example you can modify `theme.config` to use a `github` button theme by changing
-
 ```less
 @button: 'github';
 ```
 
 View the [Customization Guide](http://learnsemantic.com/developing/customizing.html) to learn more
+

data/share/views/public/plugins/semantic-ui/src/definitions/behaviors/api.js

@@ -10,7 +10,7 @@
 
 ;(function ($, window, document, undefined) {
 
-'use strict';
+"use strict";
 
 var
   window = (typeof window != 'undefined' && window.Math == Math)

data/share/views/public/plugins/semantic-ui/src/definitions/behaviors/colorize.js

@@ -0,0 +1,280 @@
+/*!
+ * # Semantic UI - Colorize
+ * http://github.com/semantic-org/semantic-ui/
+ *
+ *
+ * Released under the MIT license
+ * http://opensource.org/licenses/MIT
+ *
+ */
+
+;(function ($, window, document, undefined) {
+
+"use strict";
+
+window = (typeof window != 'undefined' && window.Math == Math)
+  ? window
+  : (typeof self != 'undefined' && self.Math == Math)
+    ? self
+    : Function('return this')()
+;
+
+$.fn.colorize = function(parameters) {
+  var
+    settings          = ( $.isPlainObject(parameters) )
+      ? $.extend(true, {}, $.fn.colorize.settings, parameters)
+      : $.extend({}, $.fn.colorize.settings),
+    // hoist arguments
+    moduleArguments = arguments || false
+  ;
+  $(this)
+    .each(function(instanceIndex) {
+
+      var
+        $module         = $(this),
+
+        mainCanvas      = $('<canvas />')[0],
+        imageCanvas     = $('<canvas />')[0],
+        overlayCanvas   = $('<canvas />')[0],
+
+        backgroundImage = new Image(),
+
+        // defs
+        mainContext,
+        imageContext,
+        overlayContext,
+
+        image,
+        imageName,
+
+        width,
+        height,
+
+        // shortcuts
+        colors    = settings.colors,
+        paths     = settings.paths,
+        namespace = settings.namespace,
+        error     = settings.error,
+
+        // boilerplate
+        instance   = $module.data('module-' + namespace),
+        module
+      ;
+
+      module = {
+
+        checkPreconditions: function() {
+          module.debug('Checking pre-conditions');
+
+          if( !$.isPlainObject(colors) || $.isEmptyObject(colors) ) {
+            module.error(error.undefinedColors);
+            return false;
+          }
+          return true;
+        },
+
+        async: function(callback) {
+          if(settings.async) {
+            setTimeout(callback, 0);
+          }
+          else {
+            callback();
+          }
+        },
+
+        getMetadata: function() {
+          module.debug('Grabbing metadata');
+          image     = $module.data('image') || settings.image || undefined;
+          imageName = $module.data('name')  || settings.name  || instanceIndex;
+          width     = settings.width        || $module.width();
+          height    = settings.height       || $module.height();
+          if(width === 0 || height === 0) {
+            module.error(error.undefinedSize);
+          }
+        },
+
+        initialize: function() {
+          module.debug('Initializing with colors', colors);
+          if( module.checkPreconditions() ) {
+
+            module.async(function() {
+              module.getMetadata();
+              module.canvas.create();
+
+              module.draw.image(function() {
+                module.draw.colors();
+                module.canvas.merge();
+              });
+              $module
+                .data('module-' + namespace, module)
+              ;
+            });
+          }
+        },
+
+        redraw: function() {
+          module.debug('Redrawing image');
+          module.async(function() {
+            module.canvas.clear();
+            module.draw.colors();
+            module.canvas.merge();
+          });
+        },
+
+        change: {
+          color: function(colorName, color) {
+            module.debug('Changing color', colorName);
+            if(colors[colorName] === undefined) {
+              module.error(error.missingColor);
+              return false;
+            }
+            colors[colorName] = color;
+            module.redraw();
+          }
+        },
+
+        canvas: {
+          create: function() {
+            module.debug('Creating canvases');
+
+            mainCanvas.width     = width;
+            mainCanvas.height    = height;
+            imageCanvas.width    = width;
+            imageCanvas.height   = height;
+            overlayCanvas.width  = width;
+            overlayCanvas.height = height;
+
+            mainContext    = mainCanvas.getContext('2d');
+            imageContext   = imageCanvas.getContext('2d');
+            overlayContext = overlayCanvas.getContext('2d');
+
+            $module
+              .append( mainCanvas )
+            ;
+            mainContext    = $module.children('canvas')[0].getContext('2d');
+          },
+          clear: function(context) {
+            module.debug('Clearing canvas');
+            overlayContext.fillStyle = '#FFFFFF';
+            overlayContext.fillRect(0, 0, width, height);
+          },
+          merge: function() {
+            if( !$.isFunction(mainContext.blendOnto) ) {
+              module.error(error.missingPlugin);
+              return;
+            }
+            mainContext.putImageData( imageContext.getImageData(0, 0, width, height), 0, 0);
+            overlayContext.blendOnto(mainContext, 'multiply');
+          }
+        },
+
+        draw: {
+
+          image: function(callback) {
+            module.debug('Drawing image');
+            callback = callback || function(){};
+            if(image) {
+              backgroundImage.src    = image;
+              backgroundImage.onload = function() {
+                imageContext.drawImage(backgroundImage, 0, 0);
+                callback();
+              };
+            }
+            else {
+              module.error(error.noImage);
+              callback();
+            }
+          },
+
+          colors: function() {
+            module.debug('Drawing color overlays', colors);
+            $.each(colors, function(colorName, color) {
+              settings.onDraw(overlayContext, imageName, colorName, color);
+            });
+          }
+
+        },
+
+        debug: function(message, variableName) {
+          if(settings.debug) {
+            if(variableName !== undefined) {
+              console.info(settings.name + ': ' + message, variableName);
+            }
+            else {
+              console.info(settings.name + ': ' + message);
+            }
+          }
+        },
+        error: function(errorMessage) {
+          console.warn(settings.name + ': ' + errorMessage);
+        },
+        invoke: function(methodName, context, methodArguments) {
+          var
+            method
+          ;
+          methodArguments = methodArguments || Array.prototype.slice.call( arguments, 2 );
+
+          if(typeof methodName == 'string' && instance !== undefined) {
+            methodName = methodName.split('.');
+            $.each(methodName, function(index, name) {
+              if( $.isPlainObject( instance[name] ) ) {
+                instance = instance[name];
+                return true;
+              }
+              else if( $.isFunction( instance[name] ) ) {
+                method = instance[name];
+                return true;
+              }
+              module.error(settings.error.method);
+              return false;
+            });
+          }
+          return ( $.isFunction( method ) )
+            ? method.apply(context, methodArguments)
+            : false
+          ;
+        }
+
+      };
+      if(instance !== undefined && moduleArguments) {
+        // simpler than invoke realizing to invoke itself (and losing scope due prototype.call()
+        if(moduleArguments[0] == 'invoke') {
+          moduleArguments = Array.prototype.slice.call( moduleArguments, 1 );
+        }
+        return module.invoke(moduleArguments[0], this, Array.prototype.slice.call( moduleArguments, 1 ) );
+      }
+      // initializing
+      module.initialize();
+    })
+  ;
+  return this;
+};
+
+$.fn.colorize.settings = {
+  name      : 'Image Colorizer',
+  debug     : true,
+  namespace : 'colorize',
+
+  onDraw    : function(overlayContext, imageName, colorName, color) {},
+
+  // whether to block execution while updating canvas
+  async     : true,
+  // object containing names and default values of color regions
+  colors    : {},
+
+  metadata: {
+    image : 'image',
+    name  : 'name'
+  },
+
+  error: {
+    noImage         : 'No tracing image specified',
+    undefinedColors : 'No default colors specified.',
+    missingColor    : 'Attempted to change color that does not exist',
+    missingPlugin   : 'Blend onto plug-in must be included',
+    undefinedHeight : 'The width or height of image canvas could not be automatically determined. Please specify a height.'
+  }
+
+};
+
+})( jQuery, window, document );

data/share/views/public/plugins/semantic-ui/src/definitions/behaviors/form.js

@@ -10,7 +10,7 @@
 
 ;(function ($, window, document, undefined) {
 
-'use strict';
+"use strict";
 
 window = (typeof window != 'undefined' && window.Math == Math)
   ? window
@@ -358,7 +358,7 @@ $.fn.form = function(parameters) {
                   module.validate.field( validationRules );
                 }
               }
-              else if(settings.on == 'blur') {
+              else if(settings.on == 'blur' || settings.on == 'change') {
                 if(validationRules) {
                   module.validate.field( validationRules );
                 }
@@ -435,16 +435,16 @@ $.fn.form = function(parameters) {
             var
               ruleName      = module.get.ruleName(rule),
               ancillary     = module.get.ancillaryValue(rule),
-              $field        = module.get.field(field.identifier),
-              value         = $field.val(),
-              prompt        = $.isFunction(rule.prompt)
-                ? rule.prompt(value)
-                : rule.prompt || settings.prompt[ruleName] || settings.text.unspecifiedRule,
+              prompt        = rule.prompt || settings.prompt[ruleName] || settings.text.unspecifiedRule,
               requiresValue = (prompt.search('{value}') !== -1),
               requiresName  = (prompt.search('{name}') !== -1),
               $label,
+              $field,
               name
             ;
+            if(requiresName || requiresValue) {
+              $field = module.get.field(field.identifier);
+            }
             if(requiresValue) {
               prompt = prompt.replace('{value}', $field.val());
             }
@@ -603,9 +603,9 @@ $.fn.form = function(parameters) {
                 }
                 else {
                   if(isRadio) {
-                    if(values[name] === undefined || values[name] == false) {
+                    if(values[name] === undefined) {
                       values[name] = (isChecked)
-                        ? value || true
+                        ? true
                         : false
                       ;
                     }
@@ -1263,10 +1263,10 @@ $.fn.form.settings = {
     isExactly            : '{name} must be exactly "{ruleValue}"',
     not                  : '{name} cannot be set to "{ruleValue}"',
     notExactly           : '{name} cannot be set to exactly "{ruleValue}"',
-    contain              : '{name} must contain "{ruleValue}"',
-    containExactly       : '{name} must contain exactly "{ruleValue}"',
-    doesntContain        : '{name} cannot contain  "{ruleValue}"',
-    doesntContainExactly : '{name} cannot contain exactly "{ruleValue}"',
+    contain              : '{name} cannot contain "{ruleValue}"',
+    containExactly       : '{name} cannot contain exactly "{ruleValue}"',
+    doesntContain        : '{name} must contain  "{ruleValue}"',
+    doesntContainExactly : '{name} must contain exactly "{ruleValue}"',
     minLength            : '{name} must be at least {ruleValue} characters',
     length               : '{name} must be at least {ruleValue} characters',
     exactLength          : '{name} must be exactly {ruleValue} characters',