Skip to content


Subversion checkout URL

You can clone with
Download ZIP
branch: master
Commits on May 20, 2015
  1. Commit 64 (Beta Candidate)

    - debugMode is now false by default - which means
      that on error, an exception is thrown, rather than
      outputting an error message in the rendered output.
      To obtain previous behavior, set debugMode to true:
    - jQuery UI widgets: There is now a specific syntax for
      setting widget properties. A tag property with an initial
      underscore will correspond to the corresponding property
      of the widget, and it can be set, and optionally data-linked
      {^{datepicker myDate _changeMonth=true ^_maxDate=myEndDate/}}
    - The $.views.sub.cvt() no longer exists. Use tag.cvtArgs().
    - AMD and CommonJs support for both JsRender and JsViews,
      providing both for NodeJS scenarios, and scenarios in which
      requireJS or similar AMD script loaders are used to load
      JsRender, JsObservable or JsViews.
    - Support for JsRender in NodeJS:
      Support for Express and Hapi view engines using JsRender
      Support for loading templates from file, on Node, using
      the syntax: tmpl="@file.path"
    - $.templates() now has an equivalent alternate name (alias):
      $.views.compile() which allows for immediate integration in some
      frameworks, such as Hapi templated views.
    - Similarly, a compiled template now has an alternative shortcut API
      for the render method. The compiled template is it's own render
      function, so for a compiled template: var tmpl = $.templates(...);
      the following are equivalent:
      tmpl.render(data, helpers);
      tmpl(data, helpers);
    - Support for allowCode has been simplified and improved. Docs to
      follow. You can now enable allowCode globally using
      $.views.settings.allowCode. A new tag: {{*: expression}} will
      return the evaluated expression - like {{: expression}} - but here
      the expression can allow any code.
    - JsRender now has noConflict support, for loading a new instance of
      JsRender, without conflict with an already loaded instance.
    - A new data-link binding: data-link="data-foo{: ...}" permits
      data-linking directly to data-foo properties of HTML elements.
    - Tag property names can now include '.' and '_' characters:
      {{myTag _a=3 b.c=4 /}}
    - Support for {^{on someMethod ... /}} as a button. For example,
      {^{on someMethod ...}}Go{{/on}} is equivalent to
      <button data-link="{on someMethod ...}">Go</button>
    - {^{foo class=...}} lets you set (and optionally bind to) the class
      of the linked HTML element.
    - {^{foo id=...}} lets you set (and optionally bind to) the id of the
      linked the HTML element.
    - {^{foo name=...}} lets you set (and optionally bind to) the name
      property of the linked HTML element.
    - If a custom tag has setSize specified as true: {..., setSize: true, ...}
      then you can set and optionally bind to the with and height properties
      to control the width and height of the linked HTML element:
      {^{foo ... width=55 ^height=expression ...}}
    - Support simplified syntax when defining custom tags with just a markup
      string (template), or jsut a render method:
      $.views.tags("myTag", "this is the template");
      $.views.tags("a", function(...){
         //this is the render function
    - The debug helpers: {{dbg:}} {{dbg ...}} {{~dbg()}} now throw and catch,
      rather than including a debugger; statement. To use this feature set
      your browser/debugger to stop on caught exceptions.
      (See also BorisMoore/jsrender#239)
    - A lot of changes have been made to considerably optimize performance
      when using JsRender to render simple templatesPerf. Optimized template
      will not need to instantiate view objects, and hence will be faster.
      A compiled template has a tmpl.useViews property which shows whether
      it allowed that optimization. (tmpl.useViews false)
    - Many improvements on jQuery UI widget integration. Docs and samples
      to come. See also download/sample-tag-controls/jsviews-jqueryui-widgets.js
    - The git project now has build support, with Gulp.
    - Improved support for data-linking without initial rendering,
      data-link="...^{...}" - which is particularly useful when using
      server-rendered content linked subsequently in browser.
    Bug Fixes:
    - BorisMoore/jsrender#239:
    - BorisMoore/jsrender#252
      (Improved syntax error message e.g.:
      '{{include}} block has {{/for}} with no open {{for}}'
    - #300
    - #301
    - #302
    - #303
    - #213 (Detection and error message)
Commits on Mar 5, 2015
  1. Commit 63 (Beta Candidate)

    - Removed minor undocumented feature where custom tags
      could return false from init.
    - When an observableArray changes, the property change
      notification for the length change is now before the
      array change notification. (For better behavior in some
      complex scenarios).
    - A new itemVar feature allows you to set a context variable
      on any tag, to provide access to the block context, even
      within nest tag blocks below.
      e.g. {{for people itemVar="~person"}}
      See BorisMoore/jsrender#256
    - New dom change notifications feature: A new domChange()
      method on data-linked tags will raise a "jsv-domchange"
      event on the parent element. {^{for}} and {^{if}} both
      use this method to raise a "jsv-domchange" event whenever
      they modify the DOM as a result of observable data changes.
      See, and unit
      tests for "jsv-domchange".
    - childTags("myFlowTag") can now be used to find instances
      of flow tags such as {{for}} and {{if}}, as well as
      custom (non-flow) tags. See unit tests,
      e.g. view.childTags(true, "if")
    - Many new unit tests added for the above new features.
    - Some small additional bug fixes.
Commits on Feb 9, 2015
  1. Commit 62 (Beta Candidate)

    - Improved support for data-linked element expressions
      using tags
      e.g. <div data-link="{if foo tmpl='...'}">
      This now supports one or more {else} expressions
      <div data-link="{if a tmpl='...'}{else b tmpl='...'}">
      It also supports linking tag expressions to different
      targets, such as title{... css-color{... class{... etc.
      data-link="title{for items tmpl='...'}{else tmpl='...'}"
      See #293
    - Tag inheritance now supports multi-level inheritance with
      easy invocation of the base class implementation using
      this.base(...) or this.baseApply(arguments):
        baseTag: "for",
        onAfterLink: function() {
      Similarly for callbacks declared declaratively on tags:
      {{for items onAfterLink=~myHelper onUpdate=~dbg}}...
      The above uses the built in ~dbg helper, and a user-provided
      helper, such as:
      function myHelper() {
    - Many new unit tests added for the above new features.
    - Some small additional bug fixes.
Commits on Dec 25, 2014
  1. Commit 61 (Beta Candidate)

    - Improved support for computed values in paths: support
      and bug fixes for templates (and data-linking) which
      include complex expressions with computed properties
      (with or without parameters), including computed values
      which return objects, and using paths which chain
      computed values - for example:
      "a.b().c.d.e(p, q).f"
    - Full support for deep paths with computed values, with
      live data binding to any chosen depth (see Breaking
      Change below), and optionally involving complex
      expressions - for example:
      "a.b()^c.d.e(p + (r - 1), q + 't').f + 'x' + g"
    (see #285):
    - Depth of binding of paths is now controlled by the '^'
      character, whether or not the path includes computed
      For example:
      will do leaf binding only, so will 'observe' (listen to)
      changes in c, but NOT changes in b(). (This is breaking,
      since previously this path DID observe b()...)
      To observe both c and b(), use the path:
      To observe ALL changes in the path - a, b() and c(),
    - Improved support for custom tag inheritance from
      base tag - e.g.: {baseTag: "for", ...}
    Bug Fixes
    - Several small additional bug fixes.
    - Many new unit tests added.
Commits on Oct 15, 2014
  1. Commit 60 (Beta Candidate)

    - Some bug fixes for childTags() API when in element-only
    - Additional work on data-linking with deep paths and
      using "onerror" - plus memory leak bug fix, for scenarios
      called out in:
    - Some additional bug fixes.
    - Many new unit tests added.
Commits on Sep 30, 2014
  1. Commit 59 (Beta Candidate)

    - Top-level binding target can now include elements with
      templated content. Top-level binding will now skip templated
      data-bound elements, rather than adding additional dual
    - Converters can be swapped through data-linked tag properties.
      e.g see unit tests:
      <input data-link="{twoWayTag name ^convert=~options.cvt}"/>
    - Data-linking with deep paths and using "onerror" now supports
      dynamically moving between valid and invalid paths (missing
      objects deeper in path) while maintaining full data-binding
      to the whole path.
    Bug fixes:
    - Some additional bug fixes.
    - Many new unit tests added.
Commits on Sep 20, 2014
  1. Commit 58 (Beta Candidate)

    - Fixes and improvements for data-linking to visible{...}
      or to different target attributes, and for overriding the
      target attribute in the tag init().
    - Many new unit tests for these scenarios.
    Bug fix:
Commits on Sep 19, 2014
  1. Commit 57 (Beta Candidate)

    Many small bug fixes and improvements, as well as the following specific
    fixes and improvements:
    Bug fixes:
      - ~tag.parents or ~parentTags now includes the current tag
      -, data, context) now supports linking without
        passing in data - e.g. for a template that links only to context or
        helpers, not to a model.
      - Structured path dependencies for tags: For compiled templates or
        data-link expression, fn.paths and fn.deps now track dependencies
        separately for each argument or property of the tag.
      - Bug fixes and improvements to filtering support on observe APIs
      - Improvements and bug fixes and unit tests within support for
        top-level data-linking $.link(expression, target, data, context)
        or $.link(true, target, data, context).
      - Fixes to $.view(container, true) for array view when array is empty.
      - data-link="... onerror=null" is now equivalent to
        data-link="... onerror=''".
Commits on Aug 11, 2014
  1. Commit 56 (Beta Candidate)

    IMPORTANT: This commit corrects an important IE8 bug that was
    in the previous commit (55)
    This commit also includes some significant updates and improvements:
    - New API for creating derived tags - simply specify "baseTag" on
      the custom tag declaration:
        range: {
          // Inherit from {{for}} tag
          baseTag: $.views.tags["for"],
      See samples:
    - trigger=true on data-linked inputs, or two-way binding now uses
      keydown - so data entry updates as you enter each key.
      Setting trigger=true on data-linked inputs, textareas, content-editable
      elements, or custom tags such as {{textbox}} (with two-way binding
      through linkedElem) now triggers immediately after keydown, rather
      than on keyup as previously.
      So setting <input data-link="name trigger=true" />. for example,
      means the name property will update as you enter each character.
    - Improvements to DataMap feature. Used for {{props}} tag.
      Examples to follow.
    - Support for loading JsObservable (jquery.obserable.js) without JsRender
      for observable-data scenarios without JsViews.
    - Support for flexible load sequence for JsViews: Can now load
      JsObservable before JsRender and JsViews, as well as the more
      normal sequence of JsRender, JsObservable, JsViews (as used in the
      single file jsviews.js).
    - Many new unit tests for JsObservable.
    - {on now supports passing parameters directly to the bound method:
      e.g. {on ... method param1 param2}
      Examples to follow.
    - Improvements to contentEditable support.
      Examples to follow.
    - Use of autoBind property on custom tags no longer necessary.
    - Bug fixes:
Commits on Jul 23, 2014
  1. Commit 55 (Beta Candidate)

    - New 'trigger' feature:
      Two-way data-linking now allows opting in to additional trigger
      events, so that data updates on every keyup event, as text is
      entered. This applies to data-linked inputs, textareas, and
      content-editable elements, as well as to custom tags, such as
      {{textbox}} which provide two-way binding through linkedElem.
      For example, setting <input data-link="name trigger=true" />
      means that updates to the name property will happen as you type,
      not just on leaving the textbox.
      See unit tests for full range of options on this feature.
    - Many new unit tests
    - Several minor bug fixes
    - All samples updated to take advantage of new 'trigger' feature.
Commits on Jul 11, 2014
  1. Commit 54 (Beta Candidate)

    Note that this update brings important perf optimizations and many
    significant feature improvements, with corresponding changes to the
    For normal usage patterns these do not correspond to breaking changes.
    However there could possibly be breaking changes on a few advanced
    If appropriate, please file issues if breaking changes are
    observed. See also the samples and unit tests for changes that take
    advantage of new features below.
    New features and improvements
    - Many major performance improvements, including much improved
      performance for {{>...}} - and optimizations allowing extremely
      fast rendering for render() in the case of simple templates.
    - Support for overriding error messages.
      $.views.settings({onError: function(...) {...}});
      (See unit tests. Examples to follow.)
    - BREAKING: {{:expression noError=true}} is no longer supported.
      Replaced by more powerful and extensible 'onError' feature below.
      (onError=null or onError='' replaces previous noError=true)
    - New 'onError' feature: fallback strings or onError handlers for
      any tag instance: e.g. {{:missing.object onError='fallbackString'}}
      or {{myTag onError=myErrorHandler/}}.
      (See unit tests. Examples to follow.)
    - Error messages are now HTML encoded when rendered into HTML by
      a .link() call.
    - support for binding to tag properties and contextual properties:
      e.g {{xxx ^foo=expr1 ^~bar=expr2}} allowing then to bind to
      or ~bar. (See unit tests. Examples to follow.)
    - tagCtx.params now provides stuctured information about props and
      args - parameter string for each
    - $.views.sub.parse(parameterExpression) converts any parameter
      expression to corresponding code.
      Include bindingsArray:
      $.views.sub.parse(parameterExpression, bindingArray) to obtain
      list of path expressions for dependencies
    - views now have a boolean 'linked' property with value 'true' if
      created via link() rather than via render()
    - Custom tags: Having an empty template: "" in tag definition is
      now supported.
    - New support for observably removing a property from an object:
    - Many improvements to feature for attaching event handlers using
      data-link="{on ... myHandler}".
      (See unit tests. Examples to follow)
    - jsonview fix to support rendering non-string values
    Bug fixes:
      - Fix for collision with tags which add props() jQuery method:
Commits on May 3, 2014
  1. Commit 53 (Beta Candidate)

    New features and improvements
    - observe()/unobserve() and observeAll()/unobserveAll() now support
      namespaces. Pass one or more (whitespace separated) namespaces
      as first parameter (where a namespace is as in jQuery events and can
      include dot-separators: "aaa.bbb.ccc"). Documentation to follow, but
      see unit tests for examples
    - In JsViews, invalid syntax using {{}} tags within element markup is
      now detected, with a specific error message.
    Bug fixes:
    - Fix for disposing contained bindings in some (unusual) scenarios
       when updating tag controls within element-only content.
Commits on Mar 25, 2014
  1. Commit 52 (Beta Candidate)

    Note that this update brings significant feature improvements
    with corresponding changes to the implementation. For normal
    usage patterns these do not correspond to breaking changes. However
    there could possibly be breaking changes on a few advanced scenarios.
    If appropriate, please file issues if breaking changes are
    observed. See also the samples and unit tests for changes that take
    advantage of new features below.
    New features and improvements
    - {{: xxx}} can now be used without arguments, so {{:}} is equivalent
      to {{:#data}}. This is a similar pattern to {{for}} {{include}} etc.
    - autoBind feature for custom tags allows a custom tag without
      argument to bind to current data context, so {{mytag/}} is
      equivalent to {{mytag #data/}}. This is achieved by setting
      autoBind: true on the tag definition.
    - Can now define a converter for the first arg on any tag - custom
      or built-in. e.g. {{for myarray convert=~reverseArray}}
      or {{mycustomtag name convert='someRegisteredConverter'/}}
      or <div data-link="name convert=formatName" /}} (in this example
      the person object has a name property and a formatName method)
    - Similarly any tag with two-way binding can have a convertBack
      e.g. <input data-link="name convert=~SomeHelper convertBack=SomeMethodOnDataObject" />
      or {^{slider speed convert=~fromMphToKmH convertBack=fromKmHtoMph/}}
      or: {^{myTextBoxTag convert=~myCnvtHelper convertBack='myregisteredConverter'/}}
    - Support for triggering updates to the tag based on dependencies
      declared for the converter as well as dependencies declared on
      the tag itself. There is also a new $.view.sub.getDeps() helper
      function for combining multiple dependency declarations - used
      internally to implement the above feature.
    - Improved support for rendering arrays without iteration:
      render(array, helpers) will iterate over the array, but you can
      now pass a 'noIteration' boolean. So render(array, true) renders
      anv array without iteration, and similarly, render(array, helpers, true)
      now renders an array without iteration while passing in helpers.
      Within methods and events of custom tags:
      tagCtx.render() renders against the current data object,
      tagCtx.render(someArray) iterates over the array
      tagCtx.render(someArray, true) or tagCtx.render(someArray, helpers, true)
      renders without iteration.
    - In a custom tag, a template can now be assigned (determined
      dynamically) in the init method simply by setting:
      this.template = templateObjectOrMarkupString;
      It is no longer necessary to write:
      this.template = tagCtx.tmpl = templateObjectOrMarkupString;
    - Support for declaring event handlers directly on tags or
      data-link expressions: {{anyTag onXxx=myXxxHandler /}}
      This can be used for standard event handlers such as onUpdate,
      onBeforeChange etc.
      e.g. <textarea data-link="text onUpdate=updateMethodOnViewModelObject"></textarea>
    - There is a new helper utility function for validation of
      HTML markup in JsViews: $.views.utility.validate(markupString)
      This could be used in the following example:
      $.views.helpers("validateMarkup", $.views.utility.validate);
      <textarea data-link="text onBeforeChange=~validateMarkup"></textarea>
    - Improved error message if JsViews or JsObservable is loaded without jQuery
    Bug fixes:
    - Fix for BorisMoore/jsrender#231
    - Fix for #198
    - Fix for #231
    - Fix for a memory leak issue
    - Fixes for some issues with radio buttons and with multiselect
    - Fixes for bugs in some samples
Commits on Jan 24, 2014
  1. Commit 51 (Beta Candidate)

    - Fix for bug #244
    - Fix for bug on data-linking to contentEditable elements
Commits on Jan 22, 2014
  1. Commit 50 (Beta Candidate)

    - Added support for getting full path in observeAll from
      root to modified object (including array indices):
    - Added support for getting parent chain in observeAll
      from modified object to root:
    - Bug fix in {^{props}} data linking
    - Fix for #240
    - Fix for BorisMoore/jsrender#228
Commits on Jan 17, 2014
  1. Commit 49 (Beta Candidate)

    - Fix for #237 (Workaround for IE9 bug)
Commits on Jan 15, 2014
  1. Commit 48 (Beta Candidate)

    New features and improvements:
    - {^{props/}} tag now supports data-linking: It is 2-way data bound.
      Samples to follow.
    - observeAll events now provides additional contextual information:
      See #232. Samples to follow.
    - observeAll(object, cb[, filter]) allows an additional 'filter' parameter:
      a function to filter returned values. The filter feature is used by the
      {{props}} implementation.
    - {{for}} {{include}} {{props}} now support omitting the data path
      parameter. When omitted, renders current data, - equivalent to
      {{for #data}} etc. {{for}} iterates if current data is an array
      {{include tmpl=…/}} renders template for current data, and does not
      iterate if current data is an array.
    - Improved API for settings, plus bug fixes. Switch debugMode using
      $.views.settings.debugMode(boolean);. Switch other settings such as
      tryCatch using $.views.settings({tryCatch: false}).
    - New support for rendering or linking arrays, without iteration (previously
      "layout = true" mode). Pass in value true for optional 'noIteration'
      parameter as in:
      tagCtx.render(someArray, context[, noIteration])
      template.render(data, context[, noiteration]), data, context[, noiteration]).
    - New support for custom tags with just a template - they no longer need a
      render method. They will iterate over arrays. To render arrays without
      iteration provide a render method which calls
      tagCtx.render(data, options, true);
      Samples to follow.
    - New support for 2-way data-linking on content-editable elements.
      Samples to follow.
    - Improvements to the "{on ...}" event binding: data-link="{on myHandler}"
      now defaults to the default trigger" "click";
    - New support for a DataMap feature used by {{props}} implementation.
      More information/samples/documentation and updates to follow.
    - New built-in tag, converter and helper provided for debugging:
      {{dbg/}}, {{dbg:somePath}}  {{myconverter:somePath:dbg}} ~dbg()
      When debugMode is true, the debugger will break at that point during
      template rendering.
    - New {{jsonview/}} sample tag control. Insert anywhere in a template
      and it will render the current data item as JSON syntax, and when
      using JsViews/link() will dynamically update when the data changes
      observably. Use {{jsonview}} to show JSON
      for nested objects.
    - Whenever the value null is returned from tag, the result is now
      consistently to render nothing (empty string). Previously {{:nullValue}}
      returned the empty string, but {^{:nullValue}}, {{attr:nullValue}} and
      {converterReturningNull:foo}} did not. This is a fix for
    - Data linking to arrays is simplified and more consistent. Now tags
      DO NOT automatically bind to arrays, and refresh when the array updates.
      {^{myTag}} will now update when the to.array property is
      update (property change) but not when the to.array itself changes
      observably. (array change). A tag should opt in to arraybinding either
      by deriving from the "for" tag - as in the 'range' sample:, or by following
      the using onAfterLink and onDispose to add/remove the onArrayChange
      handler, as in the {^{myWidget .../}} sample in the JsViews unit tests.
      This change relates to #158
    Bug fixes:
    - Fixed bugs in nested array binding (multi-dimensional arrays) See
    - Fix for #235
    - Fix for BorisMoore/jsrender#221
    - Fix for BorisMoore/jsrender#226
    - Fix for BorisMoore/jsrender#227
Commits on Nov 30, 2013
  1. Commit 47 (Beta candidate)

    Small bug fix (encoding quotes) and unit tests
Commits on Nov 25, 2013
  1. Commit 46 (Beta candidate)

    New features and improvements:
    - New {{props}} tag to iterate through fields/properties of an object:
      {{props}} {{:key}}:  {{:prop}} {{/props}}
    - Declarative event binding (documentation to follow soon):
      <button data-link="{on 'click' someMethod}">...
    - Use of #index in a nested context (e.g. in an {{if}} block) now produces
     (in debugMode === true) a warning error indicating getIndex() syntax.
      Standardization of event handler signatures and this pointer
      In event handlers:
      > onBeforeChange event handlers now expect the standard (ev, eventArgs)
        signature –, where eventArgs includes the properties change: "change",
        oldValue:…., value:…
      > The 'this' pointer in onAfterChange onBeforeChange is linkCtx
       (which provides access to many other objects/APIs, including the
       view object, as this.view).
      The tag.onChange() event for custom tag controls using 2-way binding is
      no longer provided. The tag.onBeforeChange() can be used instead for
      most scenarios.
      Overriding of global helpers, templates, tags or converters:
      > resources specific to a template (e.g. a helper in the template’s
      helpers collection) now override resources of the same name defined
      globally (e.g. using $.views.helpers("myHelper", ...); ).
      > Helpers passed in as options override both template-specific and
      global helpers of the same name.
    - A tag.onAfterBind() event is now provided.
    - "Top-level linking": $.link(true, containerSelector, options) now allows
      passing in contextual helpers etc. as options, in the same way as, options);
    - Several bug fixes
    - Many new unit tests
Commits on Oct 29, 2013
  1. Commit 45 (Beta candidate)

    Many improvements to observe() APIs.
    - Improved and simplified API for $.observable.observe().
      Simplified API - $.observe() can be used instead of $.observable.observe()
      Semantics of more complex usage of $.observe() has been simplified
      $.observe(myArray, myHandler) will listen to setting a new myArray, and
      to array changes on myArray
    - New API $(objectOrArray).observeAll(myHandler) will listen to ALL changes on
      the objectOrArray passed in and ALSO on any other objects or arrays in the
      'object graph' (child objects etc.)
      $(objectOrArray).unobserveAll(myHandler) will remove those listeners.
    BREAKING CHANGES for advanced (largely undocumented) usage of observe() API:
    a)Binding to arrays no longer requires wrapping. The syntax is now:
      $.observable.observe(myArray ... myHandler);
    b)Grouping of parameters in arrays, including objects no longer supported:
      For example this is no longer supported:
      $.observable.observe([myObject, path1], path2, ... myHandler);
    c) $(object).observe(...) and $(object).unobserve(...) variants of syntax are no
      longer supported. Use $.observe(object, ....) style instead...
    Several bug fixes and perf optimizations, including:
    - Fix for bug {{if !true}} evaluates to true. See:
    Many new documentation topics added, mostly under JsObservable API
    Many new unit tests added.
Commits on Oct 20, 2013
  1. Commit 44 (Beta candidate)

    - Fix for bug {{else someUndefinedValue}}. See:
    - Fix for issue:
    - Fixes and improvements for $.observable.observe API
    - Minor additional bug fixes and improvements
Commits on Oct 8, 2013
  1. Commit 43 (Beta candidate)

    1 $.observable(...).insert(...)
      Validation of parameters: now supports string values for index
      (does parseInt(index) internally) and requires index > - 1 and
      index <= array.length
      – otherwise noop.
      Supports alternative syntax for appending:
    1 $.observable(...).remove(...)
      Validation of parameters: now supports string values for index and
      numToRemove  (does parseInt(index) internally) and requires
      index > - 1, index < array.length and  and numToRemove > -1
      – otherwise noop.
      Supports alternative syntax for removing last item:
    1 $.observable(...).move(...)
      Validation of parameters: now supports string values for index,
      newIndex and numToMove (does parseInt(index) internally) and requires
      index > - 1, index < array.length, newIndex > - 1,
      newIndex < array.length and  and numToMove > -1
      – otherwise noop.
    - New feature - support for merge converter with toggle - See:
    - Many new unit tests added for JsObservable insert, remove and move methods.
    - Bug fix to ensure onAfterChange fires exactly once if and only if
      value has changed.
    - Small bug fix deferred annotations during data-linking
Commits on Sep 23, 2013
  1. Commit 42 (post beta)

    1: tag.contents() and view.contents(): The parameter order
       has been changed for consistency with other APIs:
         Now:          view.contents(deep, selector)
         Previously:   view.contents(selector, deep)
    2: childTags(): now returns element-based tags as well as inline tags
    3: Removed support for marking an element-based tag as inline=true
    - Added support for tag.refresh for element-based tags too - including
      with non-html targets
    - tag.onDispose is now called for both inline tags and element-based tags.
    - Added support for data-linking to SVG elements
    - Added support for void tags with no self-closing slash (issue #209)
    - Added support for two way data-binding on custom tags.
    - onBeforeChange support: Now supports returning false in order to
      suppress modification of the target data
    - tag.onUpdate support: Now supports returning false in order to
      suppress re-rendering the tag
    - Added much improved support for validation
    - Added much improved support for custom tags using widgets or plugins
      such as the jQuery UI widgets.
    - New API: getCurrentCtxs()
    - Many new samples added to, including
      custom tags for validation, and for slider, datepicker etc.
    - Many samples on the JsViews GitHub demos site removed and replaced by
      updated and improved versions on
    - Several small bug fixes
Commits on Jul 7, 2013
  1. Commit 41 (post beta)

    Continued work for two way binding of tag controls
Commits on Jul 5, 2013
  1. Commit 40 (post beta)

    - Fix for #205, #180
    - BREAKING CHANGE - tag controls with named properties will not refresh
      when the named property expression changes, unless opting in with the
      syntax ^name=expression.
      {^{tabs ^width=width+"px" ...
    - Support for using just CR as newline within templates (as well as
      CRLF or just LF, previously supported)
    - Support for tag controls with two-way binding (editable tag controls)
      with onBeforeChange - which provides for validation, by returning false,
      onChange, linkTo for binding to a different path as target, convert and
      convertBack. Support also for data-link="{:path linkTo=targetPath:}"
    - Fixes for some bugs in top-level data-linking.
Commits on Jun 20, 2013
  1. Commit 40 (Beta Candidate)

    Fix for #202
Commits on Jun 19, 2013
  1. Updated index.html

Commits on Jun 11, 2013
  1. Final commit for official JsViews v1.0.0-alpha release. (Simultaneous…

    … with the
    release of the new documentation site at
Commits on May 24, 2013
  1. Commit 38. (Beta Candidate)

    - modified approach to data-linking processing model. By default linking
      is now depth last, for better perf. If you need depth-first so nested
      tags are relinked before parents, return false from onBeforeLink
    - support for "lazy linking": {^{tag lazyLink=true}} - on refresh it will
      link asynchronously, after synchronous rendering, for better perceived
      perf in some scenarios (possible browser dependent).
    - minor bug fix for encoding of "\" characters.
    - small changes on HTML encoding code...
Commits on Apr 25, 2013
  1. Commit 37. (Beta Candidate)

    - Minor bug fixes.
    - The tag init method is now called just after the constructor, rather than
     being used as constructor, so the this pointer in the init() is a full
     instance with tag.parent and all the other properties already set...
Commits on Apr 13, 2013
  1. Commit 35. (Beta Candidate)

    Removed some TODO comments and added a fix for data-linking to the
    "selected" attribute.
Commits on Apr 10, 2013
  1. Commit 35. (Beta Candidate)

    1) Completed support for deep data-linking to complex paths which can
     include computed observables returning objects and arrays, etc.
    2) Added to observing-paths.html sample to show data-binding to an options
     list under a select, for dynamic insertion and removal of options.
    3) Added to and improved the different flavors of the editable-data.html
     sample, taking advantage of the more powerful expression/path binding
     support now available in JsViews and JsObservable.
    4) Added additional unit tests for complex scenarios of tag refresh and
     view refresh interplay, and for computed observables.
Commits on Mar 28, 2013
  1. Commit 34. (Beta Candidate)

    1) jquery.observable changes for compatibility with jQuery 2.0 Beta
    2) Attribute encoder now encodes '>', for compatibility with JsViews parsing.
    3) The View constructor is now accessed as $.views.sub.Views(), not
     $.views.Views(), since public access not needed except for rare
     advanced scenarios.
    4) Fix for small memory leak in view bindings
    5) Fix for tag.refresh and view.refresh interplay bug, and added unit tests
     for this and related scenarios.
Commits on Mar 14, 2013
  1. Commit 33. (Beta Candidate)

    Small bug fixes including for #153
Something went wrong with that request. Please try again.