Pipes a value through a series of processes.

The Uize.pipe method makes it possible to express serial processing of values in forward rather than backwards order, and also eliminates the issue of cumulative indentation that is associated with nested function calls.

IMPLEMENTATION

_package.pipe = function () {
  for (
    var
      _argumentNo = 0,
      _arguments = arguments,
      _argumentsLength = _arguments.length,
      _argument,
      _input = _arguments [0]
    ;
    ++_argumentNo < _argumentsLength;
  ) {
    _input = Uize.isArray (_argument = _arguments [_argumentNo])
      ? _argument [0].apply (0,[_input].concat (_argument.slice (1)))
      : _argument (_input)
    ;
  }
  return _input;
}

INSTEAD OF...

return Uize.Data.Csv.to (
  Uize.Data.NameValueRecords.fromHash (
    Uize.Loc.FileFormats.ProjectStrings.Util.flatten (_toEncode),
    0,
    1
  )
);

USE...

return Uize.pipe (
  _toEncode,
  Uize.Loc.FileFormats.ProjectStrings.Util.flatten,
  [Uize.Data.NameValueRecords.fromHash,0,1],
  Uize.Data.Csv.to
);

Logs a message, using the configured logging options.

SYNTAX

Uize.log (messageSTR);

IMPLEMENTATION

_package.log = function (message) {
  // fill this in
};

Would return the value of the own property of an object, but not a property value that is inherited from the object's prototype.

SYNTAX

valueANYTYPE = Uize.own (sourceOBJ,propertySTRorINT);

IMPLEMENTATION

_package.own = function (_source,_property) {
  var _result;
  return (
    _source &&
    (_result = _source [_property]) !== _undefined &&
    _source.constructor.prototype [_property] !== _undefined &&
    !_source.hasOwnProperty (_property)
      ? _undefined
      : _result
  );
};

Tries to execute the given function, executing the optional catch expression and warning, ignoring, or throwing any error that occurs.

SYNTAX

Uize.try (tryFUNC,catchFUNC);

IMPLEMENTATION

_package.warnForTryErrors = true;
_package.ignoreUncaughtTryErrors = false;
_package.try = function (_tryFunction,_catchFunction) {
  try {
    _tryFunction ();
  } catch (_error) {
    _package.warnForTryErrors && _package.warn (_error);
    if (_catchFunction) {
      _catchFunction (_error);
    } else if (!_package.ignoreUncaughtTryErrors) {
      throw _error;
    }
  }
};

Outputs to the log, depending on the configuration for warnings.

SYNTAX

Uize.warn (messageSTR);

IMPLEMENTATION

_package.logWarnings = true;
_package.warn = function (_message) {
  _package.logWarnings && _package.log (_message);
};

Warns if the specified function takes too long to complete (the function can be synchronous or asynchronous).

IMPLEMENTATION

_package.warnIfSlow = function (_function) {
  function _done () {

  }
  _function (_done);
};

Quantizes the specified number to the specified quantum size.

IMPLEMENTATION

_package.quantize = function (_value,_quantum) {
  return _quantum ? Math.round (_value / _quantum) * _quantum : _value;
};

Generates a random value from the specified range or list of possible values.

DIFFERENT USAGES

Generate a Random Number in the Range of Zero to One

randomNUM = Uize.random ();

Generate a Random Number in the Range of Zero to a Maximum Value

randomNUM = Uize.random (maxValueNUM);

Select a Random Value From a List of Possible Values

randomValueANYTYPE = Uize.random (valuesLIST);

Select a Random Characters From a Characters String

randomCharacterSTR = Uize.random (charactersSTR);

Generate a Random Integer in a Specified Range

randomINT = Uize.random (rangeLowerLimitINT,rangeUpperLimitINT);

Generate a Random Floating Point Number in a Specified Range

randomNUM = Uize.random (rangeLowerLimitNUM,rangeUpperLimitNUM,0);

Generate a Random, Custom Quantized Number in a Specified Range

randomNUM = Uize.random (rangeLowerLimitNUM,rangeUpperLimitNUM,quantumNUM);

IMPLEMENTATION

_package.random = function (_arg0,_arg1,_arg2) {
  var _random0to1 = Math.random ();
  function _randomIndex () {
    return Math.round ((_arg0.length - 1) * _random0to1);
  }
  return (
    arguments.length > 1
      ? _package.constrain (
        _arg0 + _quantize ((_arg1 - _arg0) * _random0to1,_arg2 == _undefined ? 1 : _arg2),
        _arg0,
        _arg1
      )
      : _arg0 == _undefined
        ? _random0to1
        : _package.isNumber (_arg0)
          ? Math.round (_random0to1 * _arg0)
          : _package.isList (_arg0)
            ? _arg0 [_randomIndex ()]
            : _package.isString (_arg0)
              ? _arg0.charAt (_randomIndex ())
              : _random0to1
  );
};

Wraps a function in order to protect it from possible JavaScript errors during its execution.

IMPLEMENTATION

Uize.safe = function (_function,_returnValueIfError) {
  var _hasReturnValueIfError = arguments.length > 1;
  return function () {
    try {
      return _function.apply (this,arguments);
    } catch (_error) {
      return _hasReturnValueIfError ? _returnValueIfError : _error;
    }
  };
};

This method catches errors that occur in the function that is being wrapped, returning the error if no value is explicitly specified that should be returned when an errors occur.

IMPLEMENTATION

Uize.cycleCalls = function () {
  var
    _functionNo = 0,
    _arguments = arguments,
    _totalFunctions = arguments.length
  ;
  return function () {
    _arguments [_functionNo].apply (this,arguments);
    _functionNo = (_functionNo + 1) % _totalFunctions;
  };
}

Update this method to support objects that have defined iterators.

Works much in the same way as Uize.map instead returns the matched set. Should use native filter function when appropriate.

An object built into the Uize base module that allows you to control walking through an object tree in a safe and performant way.

16.1. STILL TO DO

16.2. LATER

Adds an x property to a function to allow "function of x" value transformers to be easily manufactured from the function with specific values for the function's non-x arguments.

IMPLEMENTATION

Uize.wrap = function (_function) {
  return function () {return _function.apply (this,arguments)};
};

Uize.fox = function (_function,_wrapOriginal) {
  var _foxifiedFunc = _wrapOriginal ? Uize.wrap (_function) : _function;
  _foxifiedFunc.x = function () {
    var _arguments = Uize.copyList (arguments);
    return Uize.copyInto (
      function (x) {return _function.apply (this,[x].concat (_arguments))},
      {
        arguments:_arguments,
        getDisplayName:function () {return _foxifiedFunc.displayName || _function.name}
      }
    );
  };
  return _foxifiedFunc;
};

17.1. Example 1

Uize.fox (Uize.inRange);

var numbersIn0to100Range = Uize.filterArray (numbers,Uize.inRange.x (0,100));

17.2. Example 2

Uize.divide = Uize.fox (function (x,denominator) {return x / denominator});

Uize.divide (10,2);
Uize.divide.x (2);

17.3. Example 3

Uize.round = Uize.fox (Math.round,true); // wrap original, so as not to modify native function's properties

17.4. Example 4

Uize.isType = Uize.fox (function (x,type) {return typeof x == type});

Uize.isNumber = Uize.isType.x ('number');
Uize.isString = Uize.isType.x ('string');

17.5. Usage Examples

function (x) {return Uize.Json.to (x,'mini')}
(x) => {Uize.Json.to (x,'mini')}
x => Uize.Json.to (x,'mini')
Uize.Json.to.x ('mini')

Lets you conveniently create a function / method caller, where you can specify context, function, and arguments.

18.1. - names considered

IMPLEMENTATION

Uize.willCall = function (_context,_function,_arguments,_extraArgsMapping) {
  var _hasExtraArgsMapping = _extraArgsMapping != _undefined;
  if (_hasExtraArgsMapping)
    _arguments = _arguments ? _arguments.concat () : []
  ;
  if (typeof _function == 'string')
    _function = _context [_function]
  ;
  return (
    _hasExtraArgsMapping
      ? (
        typeof _extraArgsMapping == 'number'
          ? function () {
            _arguments [_extraArgsMapping] = arguments [0];
            return _function.apply (_context,_arguments);
          }

          // loop should be driven by _extraArgsMapping - not incoming arguments?
          // what about incoming arguments for which there are no mappings (i.e. beyond end of mapping array)
          : function () {
            for (var _argumentNo = arguments.length; --_argumentNo >= 0;)
              _arguments [_extraArgsMapping [_argumentNo]] = arguments [_argumentNo]
            ;
            return _function.apply (_context,_arguments);
          }


      )
      : _arguments && _arguments.length
        ? function () {return _function.apply (_context,_arguments)}
        : function () {return _function.call (_context)}
  );
};

Uize.functionCall = function (_function,_arguments,_extraArgsMapping) {
  return Uize.willCall (0,_function,_arguments,_extraArgsMapping);
};

EXAMPLE

var
  xSquared = Uize.willCall (Math.pow,[0,2],0),
  3ToPowerX = Uize.willCall (Math.pow,[3,0],1)
;

INSTEAD OF...

var 3ToPowerX = function (x) {return Math.pow (3,x)};

USE...

var 3ToPowerX = Uize.willCall (Math.pow,[3,0],1);

Uize.watchFunction = function (_function,_before,_after) {
  return function () {
    _before && _before (this,arguments);
    var _result = _watched.apply (this,arguments);
    _after && _after (this,arguments,_result);
    return _result;
  };
};

Uize.watchMethod = function (_context,_methodName,_before,_after) {
  if (!Uize.isInstance (_context))
    _context = _context.prototype
  ;
  var
    _watched = _context [_methodName],
    _watcher = _context [_methodName] = Uize.watchFunction (_watched)
  ;
  return {
    watch: function () {_context [_methodName] = _watcher},
    unwatch: function () {_context [_methodName] = _watched}
  };
};

Uize.memoize = function (_function) {
  var _resultsCache = {};
  return function () {
    var _cacheKey = Uize.Json.to (arguments);
    return (
      _cacheKey in _resultsCache
        ? _resultsCache [_cacheKey]
        : (_resultsCache [_cacheKey] = _function.apply (this,arguments))
    );
  };
};

Uize.memoizeMethod = function (_context,_methodName) {
  // ...
};

21.1. Support a wrap flag

hue = Uize.constrain (hue,0,360,true);

var maxMinDelta = max - min;
return ((value - min) % maxMinDelta + maxMinDelta) % maxMinDelta + min;
// what about max < min?

21.2. Unbounded

22.1. Support values for source being arrays.

Uize.reverseLookup ({
  vegetable:['potato','tomato'],
  fruit:['apple','orange']
});

{
  potato:'vegetable',
  tomato:'vegetable',
  apple:'fruit',
  orange:'fruit'
}

22.2. Support multiple values for source being the same

Uize.reverseLookup ({
  potato:'vegetable',
  tomato:'vegetable',
  apple:'fruit',
  orange:'fruit'
});

{
  vegetable:['potato','tomato'],
  fruit:['apple','orange']
}

22.3. Support Merging in to Target

23.1. Support Simple Type Source

24.1. Support Code Besides in Module Loader

Consider a facility to support multiple inheritance (may involve creating a merge service for merging data from one object into another, since it should be possible to merge additional features of a different class into an already created class, and perhaps that merge feature would also be used in the _subclass function's implementation).

26.1. Library of Dispersed Modules

27.1. Uize.clone and Circular References