JAVASCRIPT   109

Tools js

Guest on 31st May 2022 02:01:36 AM

  1. /**
  2.  * @author Tom
  3.  */
  4.  
  5. /**
  6.  * Returns true if the object is an array or is listable.
  7.  * @param {Object} object
  8.  * @return {Boolean}
  9.  */
  10. function isArrayOrListable(object) {
  11.         return isArray(object) || (object.Enumerable && !object.Dictionary);
  12. }
  13.  
  14. /**
  15.  * Creates a new array from the list starting at given offset and applying the template to each item.
  16.  * @param {Array, Object} items
  17.  * @param {Number} [offset]
  18.  * @param {Function} [template]
  19.  * @return {Array}
  20.  */
  21. function $A(list, offset, template) {
  22.         return iterate(list, stacker(template), offset);
  23. }
  24.  
  25. function translate(source, template) {
  26.         return each(source, stacker(template));
  27. }
  28.  
  29. function map(source, template) {
  30.         return each(source, mapper(template));
  31. }
  32.  
  33. function dict(source, template) {
  34.         return each(source, builder(newObject, function(target, key, value) {
  35.                 var pair = template(value, key);
  36.                 target[pair[0]] = pair[1];
  37.         }));
  38. }
  39.  
  40. function extractStrings(source, template) {
  41.         return translate(dict(source, function(value, key) {
  42.                 return [template(value, key), null];
  43.         }), function(value, key) {
  44.                 return key;
  45.         });
  46. }
  47.  
  48. /**
  49.  * Creates a new array that contains items from the list but not existing ones.
  50.  * @param {Array, Object} items
  51.  * @param {Number} [offset]
  52.  * @param {Function} [template]
  53.  * @return {Array}
  54.  */
  55. function compact(list, offset, template) {
  56.         return iterate(list, existing(stacker(template)), offset);
  57. }
  58.  
  59. /**
  60.  * Creates a new array that contains items from the list and flattens sub-lists.
  61.  * @param {Array, Object} items
  62.  * @param {Number} [offset]
  63.  * @param {Function} [template]
  64.  * @return {Array}
  65.  */
  66. function linearize(list, offset, template) {
  67.         return iterate(list, linearizing(existing(stacker(template))), offset);
  68. }
  69.  
  70. function filter(list, match, offset, template) {
  71.   return iterate(list, where(match, stacker(template)), offset)
  72. }
  73.  
  74. /**
  75.  * Returns true if the collection contains an item that matches.
  76.  * @param {Object} collection
  77.  * @param {Function} match
  78.  * @return {Boolean} result
  79.  */
  80. function includes(collection, match) {
  81.         return exists(indexOf(collection, match));
  82. }
  83.  
  84. /**
  85.  * Creates a new array that contains items from all the lists.
  86.  * @param {Array, Object} ... lists
  87.  * @return {Array}
  88.  */
  89. function concat() {
  90.         var result = [];
  91.         iterate(arguments, function(arg) {
  92.                 if (exists(arg)) {
  93.                         iterate(arg, function(item) {
  94.                                 result.push(item);
  95.                         });
  96.                 }
  97.         });
  98.         return result;
  99. }
  100.  
  101. /**
  102.  * Creates a new object that contains merged properties of the input objects.
  103.  * @params {Object} ... objects
  104.  * @return {Object}
  105.  */
  106. function merge() {
  107.         var result = {};
  108.         iterate(arguments, function(arg) {
  109.                 if (exists(arg)) {
  110.                         extend(result, arg);
  111.                 }
  112.         });
  113.         return result;
  114. }
  115.  
  116. function withoutProperties(object) {
  117.         var result = merge(object);
  118.         iterate(arguments, function(property) {
  119.                 delete result[property];
  120.         }, 1);
  121.         return result;
  122. }
  123.  
  124. function keys(source) {
  125.         return translate(source, keyGetter);
  126. }
  127. var values = translate;
  128.  
  129. /**
  130.  * Adds the value as a new property to the object,
  131.  * notifies the observer, and returns a new key.
  132.  * @param {Object} object
  133.  * @param {Object} value
  134.  * @param {Function} observer
  135.  * @return {String} key
  136.  */
  137. function addProperty(object, value, observer) {
  138.         var key = 1;
  139.         while (key in object) {
  140.                 key++;
  141.         }
  142.         object[key] = value;
  143.         observer(value, key, null);
  144.         return key;
  145. }
  146.  
  147. /**
  148.  * Changes a property with the given key of the object,
  149.  * notifies the observer if the previous value was different,
  150.  * and the returns previous value.
  151.  * @param {Object} object
  152.  * @param {Object} key
  153.  * @param {Object} value
  154.  * @param {Function} observer
  155.  * @return {Object} old
  156.  */
  157. function changeProperty(object, key, value, observer) {
  158.         var old = object[key];
  159.         if (old !== value) {
  160.                 if (exists(value)) {
  161.                         object[key] = value;
  162.                 } else {
  163.                         delete object[key];
  164.                 }
  165.                 observer(value, key, old);
  166.         }
  167.         return old;
  168. }
  169.  
  170. /**
  171.  * Changes properties of the object,
  172.  * notifies the observer with changes,
  173.  * and returns the changes.
  174.  * @param {Object} object
  175.  * @param {Object} values
  176.  * @param {Function} observer
  177.  * @return {Object} changes
  178.  */
  179. function changeProperties(object, values, observer) {
  180.         var changes = {};
  181.         enumerate(values, function(value, key) {
  182.                 var old = object[key];
  183.                 if (!equals(old, value)) {
  184.                         changes[key] = old;
  185.                         object[key] = value;
  186.                 }
  187.         });
  188.         enumerate(changes, function(value, key) {
  189.                 observer(object[key], key, value);
  190.         });
  191.         return changes;
  192. }
  193.  
  194. /**
  195.  * Replaces properties of the object with new values,
  196.  * notifies the observer with changes,
  197.  * and returns the changes.
  198.  * @param {Object} object
  199.  * @param {Object} values
  200.  * @param {Function} observer
  201.  * @return {Object} changes
  202.  */
  203. function replaceProperties(object, values, observer) {
  204.         var changes = clone(values);
  205.         enumerate(object, function(value, key) {
  206.                 if (!(key in changes)) {
  207.                         changes[key] = null;
  208.                 }
  209.         });
  210.         return changeProperties(object, changes, observer);
  211. }
  212.  
  213. /**
  214.  * Creates an accessor for a property of the object with the given key.
  215.  * @param {Object} object
  216.  * @param {String} key
  217.  * @return {Accessor} accessor
  218.  */
  219. function objectAccessor(object, key) {
  220.         return new Accessor(function() {
  221.                 return object[key];
  222.         }, function(value) {
  223.                 var oldValue = object[key];
  224.                 object[key] = value;
  225.                 return oldValue;
  226.         });
  227. }
  228.  
  229.  
  230. /**
  231.  * Creates watch getter from the watch accessor.
  232.  * @param {WatchAccessor} accessor
  233.  * @return {WatchGetter} getter
  234.  */
  235. function getWatchGetter(accessor) {
  236.         return new WatchGetter(accessor.get, accessor.observe, accessor.invokeObserver);
  237. }
  238.  
  239. /**
  240.  * Returns true if the source implements CanGet interface and canGet() returns false.
  241.  * @param {Object} source
  242.  * @return {Boolean} result
  243.  */
  244. function cannotGet(source) {
  245.         return source.CanGet ? !source.canGet() : false;
  246. }
  247.  
  248. /**
  249.  * Returns function that sets the value to the accessor.
  250.  * @param {Accessor} accessor
  251.  * @param {Object} value
  252.  * @return {Function} setter
  253.  */
  254. function setter(accessor, value) {
  255.         return function() {
  256.                 accessor.set(value);
  257.         };
  258. }
  259.  
  260. /**
  261.  * Returns the deepest accessor.
  262.  * @param {Accessor} accessor
  263.  * @return {Accessor} accessor
  264.  */
  265. function getAccessorDeep(accessor) {
  266.         while (true) {
  267.                 var value = accessor.get();
  268.                 if (!exists(value) || !value.Accessor) {
  269.                         return accessor;
  270.                 }
  271.                 accessor = value;
  272.         }
  273. }
  274.  
  275. /**
  276.  * Creates a date from a natural representation.
  277.  * @param {Number} year
  278.  * @param {Number} month
  279.  * @param {Number} day
  280.  * @param {Number} hour
  281.  * @param {Number} min
  282.  * @param {Number} sec
  283.  */
  284. function date(year, month, day, hour, min, sec) {
  285.         return new Date(year, month - 1, day, hour, min, sec);
  286. }
  287.  
  288. /**
  289.  * Creates a copy of the given date.
  290.  * @param {Date} date
  291.  * @return {Date} result
  292.  */
  293. function copyDate(date) {
  294.         return new Date(date.getTime());
  295. }
  296.  
  297.  
  298. function getArgumentsCount(func) {
  299.         // from Prototype
  300.         var items = func.toString().match(/^[\s\(]*function[^(]*\((.*?)\)/)[1].split(",");
  301.         return items.length == 1 && !items[0] ? 0 : items.length;
  302. }
  303.  
  304.  
  305. function multiDictSet(dict, key, value) {
  306.         return obtain(dict, key, newWatchList).append(value);
  307. }
  308.  
  309. function tryGet(source, key) {
  310.         return exists(source) ? source.get(key) : null;
  311. }
  312.  
  313. function path(source, path) {
  314.         indexOf(path, function(step) {
  315.                 if (!exists(source)) {
  316.                         return true;
  317.                 }
  318.                 source = source[step];
  319.         });
  320.         return source;
  321. }
  322.  
  323. function pathGet(source, path) {
  324.         indexOf(path, function(step) {
  325.                 if (!exists(source)) {
  326.                         return true;
  327.                 }
  328.                 source = source.get(step);
  329.         });
  330.         return source;
  331. }
  332.  
  333. function redirectToRoomLoc(room, loc){
  334.     indicoRequest(
  335.             'roomBooking.locationsAndRooms.getLink',
  336.             {
  337.                 room: room,
  338.                 location: loc
  339.             },
  340.             function(result,error) {
  341.                 if (!error && result) {
  342.                     window.location = result
  343.                 } else{
  344.                     new AlertPopup($T("Warning"),$T("Location not available")).open();
  345.                 }
  346.             }
  347.         );
  348. }

Raw Paste


Login or Register to edit or fork this paste. It's free.