- Improve progressive enhancement for keyed/non-keyed recycle strategies
- Use IDL attributes instead of content attributes on: checked, selected, hidden
- Minor performance fixes solved, occurred in the "keyed shuffle test"
- Use
rootas the default target forwarding on event delegation by using the colon syntaxclick="user-create:root"will always point to the component root by default.
- Web Components (Shadow DOM)
- Runtime Compiler incl. support for Web Components
- Mikado-Compile detect and replace repeated inline includes (not supported by the runtime compiler)
- New callbacks
mount,unmount - Improve
Mikado.once(): supports Web Components, improved async mode, access the low level factory constructor which performs 20% faster Mikado.once()will apply the best strategy for each scenario: 1. static non-looped templates, 2. static looped templates, 3. dynamic non-looped templates, 4. dynamic looped templates
- A whole re-build of the library
- Support partial hydration / progressive hydration focusing on maximum performance
- Mikado provides you server-side rendering on an extreme performance level
- Mikado also comes with the fastest Express Middleware Render Engine of today
- Templates are cross-compatible, uses same template markup for Server-side-rendering as for client-side-rendering
- The server-side-implementation follows the same strategy of sharing instances and includes
- Moves the creation of executable template functions to the compiler (CSP friendly)
- The core has a new architecture which improves the predecessor in any aspect
- Templates including multiple text nodes as dynamic expressions are now supported
- The cache strategy was completely redesigned, it now shares caches across multiple template expressions
- The "DOM Cache Helpers" are now fully integrated into the internal cache system, which transforms template caches into a more powerful strategy when used
- The cache injects progressively when used and don't apply in preparation by default
- The compiler provide 5 build strategies to choose from, to optimize either performance, flexibility or size
- A special compiler flag "cache" could be placed into the template markup to prebuild the strategy by the compiler
- The concept of shared pools was fully re-design. The goal is still the same but instead of sharing direct access on pools it shares instances of Mikado. This greatly improves integration, not only because instances can have their own configuration (options).
- The include system was re-build from the ground up and also support real conditional template structures through the template syntax
<div if="data.length">(they are not just "hidden" anymore) - It is now possible to combine all 3 kinds of include variants on a single element
<div if="data.length" foreach="data" include="tpl/partial"> - A new mounting system was implemented which is more robust and also support the new concept of shared Mikado instances
- The event delegation was greatly improved, it now supports bubbling same events on parents up to the HTML root element, for this workload there is a new optimization available by
Mikado.eventCache = true. - Support for SVG markup withing templates
- A new template expression
{{? ... }}to skip printing "nullable" values (except 0) - The expression
{{#= ... }}is now supported - A new template expression
{{! ... }}for escaping contents (SSR only) - Supports SSR-only mode where the limitation of having one outer element as the template root is unlocked, also there is an
extractiondirective to place logical placeholder elements, which will be self-extracted when rendered - Improved state system
- Improved bundler and export type system
- The registration of templates has improved, it starts instantiation right before related task and isn't cleanup automatically when calling
.destroy()on a parent view - The store was removed, except when using
Mikado.Array()you still need to pass in the store as the optionobserve: - The benchmark was moved to its own branch named
bench
change the option pool has changed, set it to true to use both pools: Recycle Pool + Keyed Pool, or set it to false to fully disable pooling, or set it to either one of both: "queue" or "key" to enable just one of them respectively
change the option keep was removed, because it was replaced by option pool: "key" which will switch into the "explicit keyed mode"
fix observable properties
fix purge cache
add new build flag: SUPPORT_KEYED
improve inherit cache from factory
improve add fast path within reconciliation
improve indices requires no sync anymore
change remove dom indices, method access by index is now recommended (access by node is still supported but has extra costs, prevent looping via method access by node)
new method dispatch to call/invoke an event handler manually
fix external/internal stores
add make reconcile method public
change live pool becomes a non-optional feature
new reconcile based on "longest distance strategy"
new mikado-compile: use wildcard for compiling recursively through a directory
add es6 modules for production (bundled via babel)
add TypeScript definition file
new observable array based on ES6 proxy incl. polyfill (acts like a NodeList, semantically equal to an array-like object)
change the method Mikado.new() was removed, just use Mikado() instead (it automatically returns an instance)
change there are two types of external stores: 1. an extern array which gets changes now automatically applied (to keep in sync) and 2. an observable array via Mikado.array() which is in sync per default by its nature
new support callbacks
improve support PointerEvents for the synthetic tap listener
improve improve data-driven concept
new add new "stealth" mode when proxy is used for all template statements
new option keep to force Mikado to run in exclusive keyed-shared mode
new option size to limit the pool size
new cross-shared pools
new explicit keyed paradigm
change version numbers of compiler and compiler service are now equal with Mikados version
new supports native HTML5 templates via runtime compiler
new supports template definitions as string
new method purge to cleanup shared pools
new supports multiple remove by a given range as 2nd parameter
new introduce an shared object pool and a new option flag pool to enable it
improve using pool significantly improves memory allocation (cuts down by a factor of 10)
new method unregister (accordingly to "register") which points to the same method as unload (accordingly to "load")
change removing the redundant option proxy (it will apply automatically)
improve re-assigning templates is now close as fast as re-mounting
improve sharing partials has been improved
improve destroying/re-initializing templates has been removed
improve memory footprint when re-using partials or templates has been improved
new added a new option to prefetch templates on page start
change External stores no longer automatically change.
beta new option field proxy (reactive data store).
change The preserved keyword item within templates was renamed to the more common identifier data.