Logs a message, using the configured logging options.

SYNTAX

Uize.log (messageSTR);

IMPLEMENTATION

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

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;
  };
}

Add support for _source being a string?

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

1.11.1. STILL TO DO

1.11.2. LATER

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

1.12.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 (ie. 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) {
  // ...
};

1.15.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?

1.15.2. Unbounded

1.16.1. Support values for source being arrays.

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

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

1.16.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']
}

1.16.3. Support Merging in to Target

1.17.1. Support Simple Type Source

1.18.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).

1.20.1. Library of Dispersed Modules

1.21.1. Uize.clone and Circular References

A module that lets you interlace multiple arrays into a single interlaced array, or deinterlace an interlaced array to produce the separate source arrays.

2.1.1. Uize.Array.Interlace.interlace

interlacedARRAY = Uize.Array.Interlace.interlace (sourceArraysARRAY,optionsOBJ);

Uize.Array.Interlace.interlace ([[0,1,2],['a','b','c'],['X','Y','Z']]);

[0,'a','X',1,'b','Y',2,'c','Z'];

2.1.2. Uize.Array.Interlase.deinterlace

sourceArraysARRAY = Uize.Array.Interlace.deinterlace (interlacedARRAY,totalSourceArraysINT);

Uize.Array.Interlace.deinterlace ([0,'a','X',1,'b','Y',2,'c','Z'],3);

[[0,1,2],['a','b','c'],['X','Y','Z']];

2.2.1. New 'binary' Mode for Uize.Array.Order.reorder

2.2.2. New 'evens odds' Mode for Uize.Array.Order.reorder

2.2.3. New 'odds evens' Mode for Uize.Array.Order.reorder

2.2.4. Primary, Secondary, or Even Tertiary Ordering?

Uize.Array.Records.getColumn -- migrated from Uize.Data.getColumn

Uize.Array.Records.findRows -- migrated from Uize.Data.findRows

2.3.1. Uize.Array.Records.removeMatching

2.3.2. Uize.Array.Records.retainMatching

2.4.1. Uize.Array.Sort.alphaNum

2.4.2. Uize.Array.Sort.sortBy

2.4.3. Uize.Array.Sort.indexBy

indexINT = Uize.Array.Sort.indexBy (valueANYTYPE,targetARRAY,sortValueGeneratorFUNC,directionINT);
indexINT = Uize.Array.Sort.indexBy (valueANYTYPE,targetARRAY,sortValueGeneratorSTR,directionINT);
indexINT = Uize.Array.Sort.indexBy (valueANYTYPE,targetARRAY,sortColumnINT,directionINT);

2.4.4. Uize.Array.Sort.insertBy

Uize.Array.Sort.insertBy (valueANYTYPE,targetARRAY,sortValueGeneratorFUNC,directionINT);
Uize.Array.Sort.insertBy (valueANYTYPE,targetARRAY,sortValueGeneratorSTR,directionINT);
Uize.Array.Sort.insertBy (valueANYTYPE,targetARRAY,sortColumnINT,directionINT);

2.4.5. Uize.Array.Sort.firstBy

firstANYTYPE = Uize.Array.Sort.firstBy (sourceARRAY,sortValueGeneratorFUNC,directionINT);
firstANYTYPE = Uize.Array.Sort.firstBy (sourceARRAY,sortValueGeneratorSTR,directionINT);
firstANYTYPE = Uize.Array.Sort.firstBy (sourceARRAY,sortColumnINT,directionINT);

2.4.6. Uize.Array.Sort.lastBy

firstANYTYPE = Uize.Array.Sort.lastBy (sourceARRAY,sortValueGeneratorFUNC,directionINT);
firstANYTYPE = Uize.Array.Sort.lastBy (sourceARRAY,sortValueGeneratorSTR,directionINT);
firstANYTYPE = Uize.Array.Sort.lastBy (sourceARRAY,sortColumnINT,directionINT);

2.4.7. Sorted Array Object

2.5.1. Uize.Array.Dupes.getDupes

2.5.2. Uize.Array.Dupes.getValueCount

2.5.3. Uize.Array.Dupes.getValueCounts

2.6.1. Uize.Array.Util.chunk

2.6.2. Uize.Array.Util.first

2.6.3. Uize.Array.Util.last

3.1.1. Possible Methods

_classPrototype.need = function (_property,_needer) {
  this.done ('Needed:' + _property);
  this.once (_property,_needer);
  /*?
    Instance Methods
      need

        SYNTAX
        .............................................
        myInstance.need (propertyNameSTR,neederFUNC);
        .............................................

        NOTES
        - see the companion `provide` instance method
        - compare to the related `condition system methods`
  */
};

_classPrototype.provide = function (_property,_provider) {
  var _this = this;
  _this.once (
    'Needed:' + _property,
    function () {_provider (function (_provided) {_this.set (_property,_provided)})}
  );
  /*?
    Instance Methods
      provide

        SYNTAX
        ..................................................
        myInstance.provide (propertyNameSTR,providerFUNC);
        ..................................................

        NOTES
        - see the companion `need` instance method
        - compare to the related `condition system methods`
  */
};

3.1.2. The whenever Instance Method

myWidget.whenever (
  function (theme) {return theme == 'bottle'},
  function () {
    // do stuff whenever condition is met
  }
);

myWidget.whenever (
  'theme => theme == "bottle"',
  function () {
    // do stuff whenever condition is met
  }
);

myWidget.wire (
  Uize.Class.virtualEvent ('whenever','theme => theme == "bottle"'),
  function () {
    // do stuff whenever condition is met
  }
);

myWidget.wire (
  Uize.Class.virtualEvent ('whenever',function (theme) {return theme == 'bottle'}),
  function () {
    // do stuff whenever condition is met
  }
);

myWidget.wire (
  'whenever("theme => theme == \'bottle\'")',
  function () {
    // do stuff whenever condition is met
  }
);

3.1.3. The next Virtual Event

myWidget.wire (
  'next("Click")',
  function () {
    // do something for only the very next click
  }
);

myWidget.onNext(
  'Click',
  function () {
    // do something for only the very next click
  }
);

SYNTAX

propertiesExpressionFUNC = Uize.propertiesExpression (expressionFUNC);

INSTEAD OF...

function (object) {
  return object.get ('width') * object.get ('height');
}

USE...

Uize.propertiesExpression (
  function (width,height) {return width * height};
}

A derived property is a special type of state property whose value is derived from the values of other state properties of the same instance.

EXAMPLE

_class.registerProperties ({
  _allSelected:{
    name:'allSelected',
    derived:function (totalSelected,totalItems) {return totalSelected > 0 && totalSelected == totalItems}
  },
  _oneSelected:{
    name:'oneSelected',
    derived:function (totalSelected) {return totalSelected == 1}
  },
  _someSelected:{
    name:'someSelected',
    derived:function (totalSelected) {return totalSelected > 0}
  },
  _totalSelected:{
    name:'totalSelected',
    value:0
  },
  _totalItems:{
    name:'totalItems',
    value:0
  }
});

In the above example, the allSelected, oneSelected, and someSelected state properties are all derived properties. A state property is indicated as being a derived property by the presence of the derived property in the property profile. The derived property serves both to indicate that a state property is derived, as well to provide the deriver function that indicates from which other state properties the derived property is derived and how to calculate the derived value.

3.3.1. Implementation Questions

3.3.2. Implementation Approaches

Provide a way in the Uize.Class base class to bind two state properties together, in order to keep their values synchronized.

This would provide a more concise and lightweight way of binding properties than using an instance of the Uize.Util.PropertyAdapter class.

INSTEAD OF...

Uize.Util.PropertyAdapter ({propertyA:[this,'prop'],propertyB:[slider,'prop']});

USE...

_this.bindProperty ('prop',[slider,'prop']);

BENEFITS

NOTES

Copy ability, for initial values of state properties that are arrays or objects.

Have a property that can be specified in a state property's profile, which can be used to cause properties whose initial values are object types to be initialized by cloning the initial value rather than simply setting a reference to a shared object.

Variation on constructor, where specifying a non-object for the properties has the effect of setting the value property.

For example, if Uize.Color were to become a subclass of Uize.Class...

EXAMPLE

Uize.Color ({value:'#ffffff'});  // old form
Uize.Color ('#ffffff');          // new form

Or, in the case of an existing widget class that supports the value interface...

EXAMPLE

Uize.Widget.Bar.Slider ({value:50});  // old form
Uize.Widget.Bar.Slider (50);          // old form

3.7.1. New Profile Features

Come up with a new and more concise semantics for calling methods on superclass.

POSSIBILITIES

_this.doIn (_superclass,'wireUi');

_class.doSuper (_this,'wireUi');
_class.useSuper (_this,'wireUi');
_class.callSuper (_this,'wireUi');

_superclass.on (_this,'wireUi');
_superclass.my (_this,'wireUi');
_superclass.doOn (_this,'wireUi');
_superclass.doMy (_this,'wireUi');
_superclass.useMy (_this,'wireUi');
_superclass.proto (_this,'wireUi');
_superclass.useMine (_this,'wireUi');

4.2.1. eg. for sRGB...

tuple:[
  {name:'red',shortName:'r',min:0,max:255},
  {name:'green',shortName:'g',min:0,max:255},
  {name:'green',shortName:'b',min:0,max:255}
]

4.2.2. - with component profile, instance methods could be supported, like...

myColor.getComponent ('red')

Certain formats for representing data may produce ambiguity.

For instance, a color can be represented in both the RGB and HSL color spaces using an array with three elements. For certain colors, it cannot be automatically determined by the values of the elements which color space the color is being specified in. In such cases, a color value may be wrapped in an object with only one key, where the key's name specifies the color's encoding (color space and format), and where the value represents the encoded color.

4.4.1. - with values...

Uize.Color.blend ({hslArray:[200,100,40]},{hslArray:[240,10,0]},.25);

dojox.color.blend (dojox.color.fromHsl(200,100,40),dojox.color.fromHsl(240,10,0),.25);

4.4.2. - with array variables

Uize.Color.blend ({hslArray:myHslColor1Array},{hslArray:myHslColor2Array},.25)

dojox.color.blend (
  dojox.color.fromHsl(myHslColor1Array[0], myHslColor1Array[1], myHslColor1Array[2]),
  dojox.color.fromHsl(myHslColor2Array[0], myHslColor2Array[1], myHslColor2Array[2]),
  .25
);

dojox.color.blend (
  dojox.color.fromHsl.apply(0,myHslColor1Array),
  dojox.color.fromHsl.apply(0,myHslColor2Array),
  .25
);

eg. {gray:50}

6.3.1. - should it be possible to do a primary,secondary,tertiary component-based subsort after a proximity sort?

6.4.1. - returns the closest match to a reference color, out of a specified array of colors

colorsARRAY = Uize.Color.makeSeries (
  color1ANYTYPE,
  color2ANYTYPE,
  componentChaosFLOATorARRAY,
  outputEncodingSTR
);

eg. Uize.Color.makeSeries ('0','f',100)

eg. Uize.Color.makeSeries ('0','f',100,0,'#hex')

component chaos of 1 lets you create any number of random colors within a range

Uize.Css.fromProperty

Uize.Css.toProperty

Uize.Css.fromPropertyName

Uize.Css.toPropertyName

Uize.Css.fromPropertyValue

Uize.Css.toPropertyValue

Uize.Css.fromProperties

Uize.Css.toProperties

Uize.Css.fromRule

Uize.Css.toRule

Uize.Css.Shadow

Uize.Css.BoxRadius

Uize.Css.Gradient

Uize.Css.Background

Uize.Css.Border

12.1.1. - a curve function modifier that...

12.3.1. - possible implementation...

_package.noise = function (_curveFunction,_noiseLevel) {
  /*** parameter defaulting ***/
    _curveFunction = _resolve (_curveFunction);
    if (_noiseLevel == _undefined) _noiseLevel = .25;

  function _noiseCurveFunction (_value) {
    function _getNoiseValue (_value) {
      var
        _cycles = 20,
        _cycle = ((_value / .001) % 20) / (_cycles - 1)
      ;
      if (!(Math.floor (_cycle) % 2)) _value = (_value + .05) % 1;
      return (Math.pow (_cycle,Math.abs (_value - 1 / (_cycle || .001) / ((1 - _value) || .0001),1)) / ((1 - _value) || .0001)) % 1;
    }
    return (_getNoiseValue (_value) + _getNoiseValue (((1 - _value) * Math.PI) % 1)) % 1;
  }

  return (
    !_noiseLevel
      ? _curveFunction
      : _noiseLevel == 1
        ? _noiseCurveFunction
        : function (_value) {
          return _blendFloats (_curveFunction (_value),_noiseCurveFunction (_value),_noiseLevel);
        }
  );
};

Uize.Curve.Plot.plot (pointsARRAY)
Uize.Curve.Plot.plot (pointsARRAY,interpolationCurveFUNC)
Uize.Curve.Plot.plot (pointsARRAY,interpolationCurveFUNC,distributionCurveFUNC)

13.1.1. pointsARRAY can be...

14.1.1. - possible implementation

var _problemKeys = {constructor:1,toString:1,valueOf:1};
Uize.Data.safeLookup = function (_lookup,_key) {
  if (_problemKeys [_key]) {
    var
      _value = _lookup [_key],
      _lookupConstructor = _lookup.constructor
    ;
    return _lookupConstructor && _value == _lookupConstructor.prototype [_key] ? _undefined : _value;
  } else {
    return _lookup [_key];
  }
};

_package.resolveSourceAndTarget = function (_source,_target,_targetDefault,_keysMayChange,_emptyOutTarget) {
  if (_target === _undefined) _target = _targetDefault;
  if (typeof _source == 'number') {
    _source = new Array (_source);
    if (typeof _target != 'object') _target = _source;
  } else if (typeof _target != 'object') {
    _target = !_target ? _source : Uize.isArray (_source) ? [] : {};
  }
  if (_keysMayChange && _target == _source)
    _source = Uize.isArray (_source) ? _source.concat () : Uize.copyInto ({},_source)
  ;
  _target != _source && _emptyOutTarget && Uize.emptyOut (_target);
  return {source:_source,target:_target};
};

usage...

var _sourceAndTarget = Uize.Data.resolveSourceAndTarget (_source,_target,true);
_source = _sourceAndTarget._source;
_target = _sourceAndTarget._target;

14.3.1. - support for new filter types

14.4.1. - finish up support for tree equality mode

14.4.2. - how to support comparison of Uize subclass instances? Is there a meaningful way to do this?

17.4.1. - support more range types

17.7.1. - could be refactored to make use of new =Uize.Date.constrain= method

18.2.1. - allow format to be a function that accepts an object containing the values for all the date components

18.3.1. - possible encoding options / switches

18.3.2. - possible loose rules around certain separator characters

18.3.3. - consider making dates not validate when values for equivalent / overlapping date components don't agree

An issue right now with the section title aliases feature is that multiple sections with the same display title but different aliases are not canonicalized into the same section.

This is because the canonicalization is done using the unaltered section title - complete with its section aliases. So, two sections that are ostensibly the same but that have different aliases are not viewed as the same because their titles including aliases are not identical. The solution would be to detect aliases in the title and canonicalize using just the displayed portion of the title.

20.2.1. - warnings

20.2.2. - should never link to the section within that same section, unless...

20.3.1. - add ability to formally describe individual columns

21.1.1. - module level info

21.1.2. - feature level info

21.1.3. - more module utilities

22.1.1. eg.

quantization:{
  '*':1,
  opacity:0
}

1 = gets to end immediately

2 = start value, then end value

n = start value, update 2, update 3, ..., end value

24.1.1. eg.

Uize.Fade.fadeProperty (slider,'value',null,['+',10])
Uize.Fade.fadeProperty (slider,'value',null,['+',10])
Uize.Fade.fadeProperty (slider,'value',null,['+',incAmount])
Uize.Fade.fadeProperty (slider,'value',null,['-',10])
Uize.Fade.fadeProperty (slider,'value',null,['%',110])
Uize.Fade.fadeProperty (slider,'value',null,['*',1.1])
Uize.Fade.fadeProperty (slider,'value',null,['=',110])
Uize.Fade.fadeProperty (slider,'value',null,['=',function (value) {return value * 1.1}])

25.2.1. - look into support for HSL color fades

28.1.1. - a widget class should be able to register which of its state properties affect display

if (property values are modified) {
  displayPropertiesModified = /* code to determine this */
  if (displayPropertiesModified.length) {
    displayPropertiesOnlyReflectedByRenderWereModified = /* code to determine this */
    if (displayPropertiesOnlyReflectedByRenderWereModified && can re-render DOME) {
      unwireUi ();
      remove DOM
      re-render DOM and insert
      wireUi ();
      remove properties handled by re-render from displayPropertiesModified
    }
    if (displayPropertiesModified.length) {
  }
}

28.1.2. - html state property

28.3.1. - state properties

28.3.2. - getOutput (params,callback)

28.5.1. - thoughts

28.5.2. Uize.Generator (base class)

28.5.3. Uize.Generator.Basic (utilizing basic substitution)

Uize.Generator.Basic ({
  params:['property1','property2'],
  templateStr:'This template supports [#property1] and [#property2]'
});

28.5.4. Uize.Generator.Tokenized

Uize.Generator.Tokenized ({
  params:['property1','property2'],
  templateStr:'This template supports {property1} and {property2}',
  tokenNaming:'{KEY}'
})

28.5.5. Uize.Generator.Population

Uize.Generator.Population ({
  params:['property1','property2'],
  templateStr:'This template supports property1Value and property2Value',
  templateItem:{
    property1:'property1Value',
    property2:'property2Value'
  }
})

28.5.6. Uize.Generator.Function

Uize.Generator.Function ({
  params:['property1','property2'],
  generator:
    function (_params) {
      return 'This template supports ' + _params.property1 + ' and ' + _params.property2;
    }
});

28.5.7. Uize.Generator.Ajax

Uize.Generator.Ajax ({
  params:['property1','property2'],
  url:'service/getcomponent?'
});

28.5.8. Uize.Generator.Async

Uize.Generator.Http

Uize.Is.greaterThan
Uize.Is.lessThan
Uize.Is.emailAddress
Uize.Is.Url
Uize.Is.Color

29.2.1. - test

Uize.Is.inRange (0,100,value)

29.2.2. - make tester

function (value) {return Uize.Is.inRange (0,100,value)}

Uize.Is.inRange.fn (0,100)
Uize.Is.inRange.tester (0,100)
Uize.Is.inRange.test (0,100)
Uize.Is.inRange.match (0,100)
Uize.Is.inRange.matcher (0,100)
Uize.Is.inRange.value (0,100)

Uize.Is.inRange.make (0,100)
Uize.Is.inRange.capture (0,100)
Uize.Is.inRange.freeze (0,100)

Uize.Is.inRange._(0,100)
Uize.Is.inRange ['...'] (0,100)
Uize.Is.inRange ['?'] (0,100)

29.2.3. - more thoughts on make tester

Uize.Is.instanceOf (Uize.Widget.FormElement,myInstance)
Uize.Is.instanceOf (Uize.Widget.FormElement) (myInstance)
Uize.Is.instanceOf.tester (Uize.Widget.FormElement)

The following proposed interface aims to address the desire amongst Web developers for easier and more concise ways to access and manipulate DOM elements.

33.1.1. The Uize.Node Object

var myNode = Uize.Node ('#myNodeId');
myNode.style ({
  border: '1px',
  background: '#ccc'
});
myNode.display (false);
myNode.on (
  'click',
  function () {
    // do something
  }
);

33.1.2. Node Blob Management

33.1.3. Versatile Setter and Getter Signatures

var stylePropertyValueSTR = Uize.Node.style (nodeBLOB, stylePropertyNameSTR);

var stylePropertiesValuesARRAY = Uize.Node.style (nodeBLOB, stylePropertiesNamesARRAY);

Uize.Node.style (nodeBLOB, stylePropertiesOBJ);

Uize.Node.style (nodeBLOB, stylePropertiesNamesARRAY, stylePropertiesValuesARRAY);

Uize.Node.style (nodeBLOB, stylePropertiesNamesARRAY, stylePropertyValuePRIMITIVE);

33.1.4. Shortened Method Names

33.1.5. Convenience Event Wiring Methods

33.1.6. Combo Setter and Getter Methods

33.1.7. Method Chaining

Uize.Node ('#myNodeId')
  .style ({display: 'none', position: 'absolute'})
  .on (
    'click',
    function () {
      // handle click event
    }
  )
;

33.1.8. Uize.Node.style

Uize.Node.style ('#myNodeId', 'display', 'none');
Uize.Node.style ('#myNodeId', {display: 'none', position: 'absolute'});
var nodeDisplay = Uize.Node.style ('#myNodeId', 'display');

Uize.Node ('#myNodeId').style ('display', 'none');
Uize.Node ('#myNodeId').style ({display: 'none', position: 'absolute'});
var nodeDisplay = Uize.Node ('#myNodeId').style ('display');

33.1.9. Uize.Node.on

Uize.Node.on (
  '#myNodeId',
  'click',
  function () {
    // handle click event
  }
);

Uize.Node ('#myNodeId').on (
  'click',
  function () {
    // handle click event
  }
);

33.3.1. - respect disabled property?

33.4.1. **** make sure that Uize.Node.wire handles rewiring the same event for the same node

33.4.2. - for all widget classes...

33.5.1. - IDEA: respecting initial non-none display value

var currentDisplay = Uize.Node.getStyle (node,'display');
if (mustDisplay != (currentDisplay != 'none')) {
  if (mustDisplay) {
    node.style.display = node.OLDDISPLAY || 'block';
  } else {
    node.OLDDISPLAY = currentDisplay;
    node.style.display = 'none';
  }
}

33.7.1. - think about testing...

35.2.1. - examples

36.1.1. - match(matchObject)

36.1.2. - key abstractions

36.1.3. - keyDown(keyName)

36.1.4. - keyPressed(keyName)

36.1.5. - inState({state:'mouseover',shiftKey:true})

36.1.6. - notInState({state:'mouseover',shiftKey:true})

36.1.7. - not quite sure what to do with these ones...

36.1.8. - sector detection events

!!!!!! store the reconstruction sequence so that it is only ever reformulated if the templateItem or templateStr are modified. This will optimize the repeat use of an instance, which is common in Zazzle's design tool attribute selectors.

37.2.1. - add support for an optional tokenNaming scheme param

38.4.1. - an option for evaluating libraries before and after they are scrunched, and reporting the position in the source code for syntax errors

var
  blah = 1234
  blahBlah = 123
;

_classPrototype.myMethod1 = function () {
}
_classPrototype.myMethod2 = function () {
};

38.5.1. - deal with the following two cases...

yeah?

39.3.1. Uize.String.[someMethodName]

40.1.1. - backwording

40.1.2. - modes for intra-word hyphening

Uize.String.Lines.removeLineNumbering ??

41.1.1. Uize.String.Lines.consolidateBlanks

Uize.String.Lines.consolidateBlanks = function (_sourceStr) {
  var _previousIsBlank;
  return _package.modify (
    _sourceStr,
    function (_line) {
      var
        _isBlank = !Uize.String.trim (_line),
        _keepLine = !_isBlank || !_previousIsBlank
      ;
      _previousIsBlank = _isBlank;
      return _keepLine;
    }
  );
};

41.1.2. Uize.String.Lines.pad

41.1.3. Rearranging Lines

function sortMultilineStr (sourceStr) {
  return (
    Uize.String.Lines.split (sourceStr).sort (
      function (a,b) {return a < b ? -1 : 1}
    ).join (
      Uize.String.Lines.getLinebreakType (sourceStr)
    )
  );
}

Subclassing of templates would allow template subclasses to more easily use the rendering features of their base classes.

Also, any features defined in a template base class and that are used for rendering can then be accessed of public instance methods from the subclass. Perhaps a separate question is how .jst files that can be compiled into template modules can expose generator functions as methods, to be used by external code. Would the input directive then define the properties for the class?

42.2.1. - colors

42.2.2. - dates

<%= '12/31/2007' -> date('{YY}-{MM}-{DD}') %>

42.2.3. - urls

<%= myRelativeUrl -> absoluteUrl('http://www.uize.com') %>

42.2.4. - string encodings

conformer:Uize.Util.Conformer.oneOf (['auto','always'],'auto')

conformer:Uize.Util.Conformer.oneOf (['auto','always']),
noSetIfConformed:true

Uize.Util.Conformer.oneOf (['auto','always'],'auto')
Uize.Util.Conformer.oneOf (['auto','always'],'auto') (blah)

Uize.Util.Conformer.string ()
Uize.Util.Conformer.bool ()

Uize.Util.Conformer.chain (
  Uize.Util.Conformer.string (),
  Uize.Util.Conformer.oneOf (['auto','always'],'always')
)

Uize.Util.Conformer.chain (
  'string',
  ['oneOf',['auto','always'],'always']
)

function _bool (_value) {return !!(typeof _value == 'object' && _value ? _value.valueOf : _value)}
_package.bool = function () {return _bool};

var _trueValuesMap = {1:1,TRUE:1,ON:1,YES:1};
function _switchBool (_value) {
  if (typeof _value == 'object' && _value)
    _value = _value.valueOf ()
  ;
  return (
    typeof _value == 'boolean'
      ? _value
      : (_value = (_value + '').toUpperCase ()) == '1' || _value == 'TRUE' || _value == 'ON' || _value == 'YES'
  );
}
_package.switchBool = function () {return _switchBool};

function _string () {return _value + ''}
_package.string = function () {return _string};

function _number (_value) {return +_value}
_package.number = function () {return _number};

_package.range = function (_minValue,_maxValue) {
  return function (_value) {Uize.constrain (_value,_minValue,_maxValue)};
};

_package.oneOf = function (_values,_default) {
  if (_default == _undefined) _default = _values [0];
  var _valuesLookup = {};
  for (var _valueNo = -1, _valuesLength = _values.length; ++_valueNo < _valuesLength;)
    _valuesLookup [_values [_valueNo]] = 1
  ;
  _valuesLookup.toString = _valuesLookup.valueOf = 0;
  return function (_value) {_valuesLookup [_value] ? _value : _default};
};

Support an array of event name/event handler pairs.

SYNTAX

myWidget.wireNode (
  'nodeName',
  [
    'event1Name',handler,
    'event2Name',handler,
    'event3Name',handler
  ]
)

50.4.1. - register updaters

50.4.2. - viewed properties

50.4.3. - when the values of viewed properties change, one of two things can happen...

50.4.4. - UI Updater

50.4.5. - questions to resolve

BEFORE

_classPrototype._updateUiValue = function () {
  var _this = this;
  if (_this.isWired) {
    // code to update UI for value
  }
};

_classPrototype.updateUi = function () {
  this._updateUiValue ();
};

_class.registerProperties ({
  _value:{
    name:'value',
    onChange:_classPrototype._updateUiValue
  }
});

AFTER

_class.registerProperties ({
  _value:'value'
});

_class.registerUiUpdater (
  'value',
  function () {
    var _this = this;
    // code to update UI for value
  }
);

When you register a UI updater, the UI updater system makes sure that Changed.[propertyName] event handlers are registered for all the properties that the UI updater serves. If values for any viewed properties are changed, then the UI updater system should execute registered UI updaters if possible, or flag the viewed properties whose values have changed as needing synchronization.

50.4.6. - Benefits

50.10.1. - different caching levels

50.10.2. - possible caching switch

50.11.1. - new names

50.13.1. - PROBLEM: can't rely on wireUi as single gatekeeper because it gets overrided by subclasses, unless you try to tuck the logic into the conditional check and change its semantics...

if (!_this.wired ()) {
  // wire stuff up
}

if (!_this.prepareToWire ()) {
  // wire stuff up
}

50.13.2. - implement backwards compatibility as...

insertUi = function () {
  this.set ({_built:_false)
  this.wireUi ();
};

Support a new mode for building the HTML for a widget, where the template for a widget does not build the HTML for all child widgets, but has inputs or tokens for the HTML of all child widgets, and where the HTML for child widgets is built independently first before being supplied to the template for the widget.

If all widgets on a widget tree are put into this mode for building their HTML, then building the HTML for a page can be a depth first recursive process. This is a cleaner model, because it doesn't require the template for a given widget to use template for child widgets in order to generate HTML, but the template for any widget is only required to generate HTML for itself and what it directly knows about.

50.16.1. eg.

_this.node (nodeName,'methodName',param1,param2,...)
a_a.node (nodeName,'methodName',param1,param2,...)

_Uize_Node.methodName (_this.getNode (nodeName),param1,param2,...)
a_a.methodName (a_a.getNode (nodeName),param1,param2,...)

50.16.2. - benefits

50.17.1. - dynamically construct such methods, in order to avoid adding too much to code size

function _makeNodeMethod (_methodPrefix,_methodSuffix) {
  _classPrototype [_methodPrefix + 'Node' + _methodSuffix] = new Function ('arguments [0] = this.getNode (arguments [0]); return Uize.Node.' + _methodPrefix + _methodSuffix + '.apply (0,arguments)');
}

_makeNodeMethod ('set','Value'); // creates setNodeValue
_makeNodeMethod ('get','Style'); // creates getNodeStyle

60.1.1. - power

60.1.2. - int