once.js

/**
 * angular-once - one time bindings for AngularJS
 * @version v0.1.7
 * @link https://github.com/tadeuszwojcik/angular-once
 * @author Tadeusz Wójcik <tadeuszwojcik@gmail.com>
 * @license WTFPL License, https://github.com/tadeuszwojcik/angular-once/blob/master/LICENSE.txt
 */

(function (window, angular, undefined) {
  'use strict';

  function setOneTimeBinding($scope, element, watch, watcherParser, bindingParser, done, useOldValue) {
    // get value to watch
    var watchingValue = watcherParser($scope);
    // if we have a valid value, render the binding's value
    if (watchingValue !== undefined && !angular.equals($scope['prev' + watch], watchingValue)) {
      // if watching and binding $parsers are the same, use watching's value, else $parse the new value
      done(element, watcherParser == bindingParser ? watchingValue : bindingParser($scope), $scope['prev' + watch]);
      if (useOldValue) {
        $scope['prev' + watch] = watchingValue;
      }
      return;
    }

    // we do not have a valid value, so we register a $watch
    var watcherRemover = $scope.$watch(watch, function (newValue, oldValue) {
      // wait until we have a valid value
      if (newValue == undefined) return;
      // remove this $watch
      removeWatcher();
      // if watching and binding $parsers are the same, use watching's value, else $parse the new value
      return done(element, watcherParser == bindingParser ? newValue : bindingParser($scope), useOldValue ? oldValue : null);
    });
    function removeWatcher() {
      if (watcherRemover) {
        watcherRemover();
      }
    }

    $scope.$on("$destroy", removeWatcher);
  }

  var once = angular.module('once', []);

  var onRefresh = ['onceChange'];

  function makeBindingDirective(definition) {
    once.directive(definition.name, ['$parse', function ($parse) {
      return {
        priority: definition.priority || 0,
        link: function ($scope, element, attrs) {
          var watch = attrs.onceWaitFor || attrs[definition.name];
          var firstBind = false;
          var useOldValue = false;

          var _bind = function (w, n, b) {
            var watcherParser = $parse(watch);
            var bindingParser = attrs.onceWaitFor ? $parse(attrs[n]) : watcherParser;
            setOneTimeBinding($scope, element, watch, watcherParser, bindingParser, b, useOldValue);
            firstBind = true;
          };

          if (onRefresh.indexOf(definition.name) !== -1) {
            return;
          }

          if ('onceChange' in attrs) {
            useOldValue = true;
            $scope.$on(attrs.onceChange, function () {
                if (!firstBind) {
                    return;
                }
                _bind(watch, definition.name, definition.binding);
              });
          }

          _bind(watch, definition.name, definition.binding);
        }
      };
    }]);
  }

  var bindingsDefinitions = [
    {
      name: 'onceChange',
      binding: function (element, value) {

      }
    },
    {
      name: 'onceText',
      binding: function (element, value) {
        element.text(value !== null ? value : "");
      }
    },
    {
      name: 'onceHtml',
      binding: function (element, value) {
        element.html(value);
      }
    },
    {
      name: 'onceSrc',
      priority: 99,
      binding: function (element, value) {
        element.attr('src', value);
      }
    },
    {
      name: 'onceHref',
      priority: 99,
      binding: function (element, value) {
        element.attr('href', value);
      }
    },
    {
      name: 'onceTitle',
      binding: function (element, value) {
        element.attr('title', value);
      }
    },
    {
      name: 'onceAlt',
      binding: function (element, value) {
        element.attr('alt', value);
      }
    },
    {
      name: 'onceId',
      binding: function (element, value) {
        element.attr('id', value);
      }
    },
    {
      name: 'onceIf',
      priority: 600,
      binding: function (element, value) {
        if (!value) {
          element.remove();
        }
      }
    },
    {
      name: 'onceClass',
      binding: function (element, value, oValue) {
        if (angular.isObject(value) && !angular.isArray(value)) {
          var results = [];
          angular.forEach(value, function (val, index) {
            if (val) results.push(index);
          });
          value = results;
        }

        if (oValue) {
          if (angular.isObject(oValue) && !angular.isArray(oValue)) {
            var results = [];
            angular.forEach(oValue, function (val, index) {
              if (val) results.push(index);
            });
            oValue = results;
          }
          element.removeClass(angular.isArray(oValue) ? oValue.join(' ') : oValue);
        }

        if (value) {
          element.addClass(angular.isArray(value) ? value.join(' ') : value);
        }
      }
    },
    {
      name: 'onceStyle',
      binding: function (element, value) {
        element.css(value);
      }
    },
    {
      name: 'onceShow',
      binding: function (element, value) {
        if (value) {
          element.css('display', '');
        } else {
          element.css('display', 'none');
        }
      }
    },
    {
      name: 'onceHide',
      binding: function (element, value) {
        if (value) {
          element.css('display', 'none');
        } else {
          element.css('display', '');
        }
      }
    }
  ];

  angular.forEach(bindingsDefinitions, makeBindingDirective);

  once.directive('once', ['$parse', function ($parse) {
      return function ($scope, element, attrs) {
          angular.forEach(attrs, function (attr, attrName) {
              if (!/^onceAttr[A-Z]/.test(attrName)) return;
              var watch = attrs.onceWaitFor || attrs[attrName];
              var watcherParser = $parse(watch);
              var bindingParser = attrs.onceWaitFor ? $parse(attrs[attrName]) : watcherParser;
              var binding = function (element,value) {
                  var dashedName = attrName.replace(/[A-Z]/g, function (match) { return '-' + match.toLowerCase(); });
                  var name = dashedName.substr(10);

                  element.attr(name, value);
              }
              setOneTimeBinding($scope, element, watch, watcherParser, bindingParser, binding);
          });
      };
  }]);

})(window, window.angular);