Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

add generic afterRender binding #2310

Merged
merged 5 commits into from
Nov 4, 2017
Merged

add generic afterRender binding #2310

merged 5 commits into from
Nov 4, 2017

Conversation

mbest
Copy link
Member

@mbest mbest commented Oct 12, 2017

that works with any binding that calls ko.applyBindingsToDescendants or with just normal binding processing (more tests to come).

…sToDescendants or with just normal binding processing (more tests to come).
@mbest
Copy link
Member Author

mbest commented Oct 14, 2017

@brianmhunt What do you think of this?

@brianmhunt
Copy link
Member

I think this is a great idea, and - with one caveat - I think this is the right implementation for knockout 3.x.

The caveat is that afterRender should probably in the future also handle asynchronous peer bindings. I don't think that's feasible in KO 3.x but it is in tko since applyBindings* return promises, so we just want to be future-proof.

Because of the way tko works, it may be possible for afterRender to be a proper binding (i.e. no changes to core), so the core code will be different but the tests should be pretty much the same and I don't think there'd be any issues with backwards compat.

@mbest do you think afterRender should always be async? Or only async when at least one child-binding is async?

Other than that, it looks good.

@codymullins
Copy link

Am I understanding this correctly that this notifies the parent when the child is rendered? Can the child's "callback" also get called when it is rendered?

@mbest
Copy link
Member Author

mbest commented Nov 2, 2017

@codymullins Any binding on the "child" will get updated when it's rendered. It's not difficult to run something on the element itself.

…d foreach bindings. Add framework for addition binding events.
@mbest
Copy link
Member Author

mbest commented Nov 3, 2017

After making this work generically, I felt that the afterRender term was no longer appropriate. After mulling it over, I've changed it to childrenComplete.

@mbest mbest merged commit 3d7cf10 into master Nov 4, 2017
@mbest mbest deleted the afterRender-generic branch November 4, 2017 21:27
brianmhunt added a commit to knockout/tko that referenced this pull request May 13, 2018
brianmhunt added a commit to knockout/tko that referenced this pull request Jun 15, 2018
* yarn) Update the packages so rollup can be used in each package directory

* tko) Fix export of `when`

* knockout) Add knockout proper package, plus somewhat modified spec from 3.5

See packages/knockout/spec/README.md

* Fix `jasmine.Clock.useMockForTasks`

* Expand tests to all `spec/` subdirectories

Also allow package.json’s `karma.files` to overload the default (by e.g. making them watchable)

* Fix semicolon hoisting variables to global scope

* spec) Remove duplicate import

* Upgrade devDependencies to latest

* karma) Fix relative `__dirname` import

* rollup) Better re-use of the path replacement

* observableArray - fix `compareArrays` tests

* npm) Update to latest packages, add globals, use .es6 knockout for testing

If we use `dist/knockout.js` for testing the knockout package, then we have to recompile every single dependency.  If we attempt to link directly to the files `src/index.js` as we do for the .es6 variants then Typescript does not inject its tslib dependencies.

So we test off of `dist/knockout.es6.js`.  One still has to recompile knockout to re-test every change.

* expose `ko.selectExtensions`

* knockout/templating) Fix a variety of template-related tests

* Down to 76 failing tests; fixes for templating and expressionRewriting behaviors

* Fix tests with dependencyDetection, postJson, and $context.ko (62 fail)

See `testing.md` for details

* tko.utils.functionRewrite) Add a basic util for backwards compat with `funciton () {}` in binding strings

* Add Backers.md for Pateron support

* parser) Add basic function rewriter to the default parser

Adds option `bindingStringPreparsers`

* build) Respect a `—es6` option to `yarn build` to speed up compilation

* string) Remove legacy `stringifyJson`

* #56 ) Break out common elements of knockout/tko compilation to `tko.builder`

This may have caused a couple regressions in tests, but they should be easy to find.

* packages) Fix configs for tko.functionRewrite and tko.builder

* rollup) Fix renamed config option

* export `utils.cloneNodes`

* Support ES2015 object initializer short-hand `{name}`

* function-rewrite) Rewrite arguments passed to lambdas

Note: arguments are not yet respected by the parser/interpreter.

* knockout) Put the `options in the correct place

* dev) Ignore `.vscode`

* parser) Add tests for calling lambdas created by the parser

Some lambdas may be passed into bindings.

* Add monkeypatch to fix the broken test system by breaking it

Time consuming & frustrating to diagnose.

* knockout) Fix tests related to `task` `scheduler` and `onError`

* Expose `ko.computedContext` as alias of `ko.dependencyDetection`

* Fix test for .length

* Update npm dependencies to latest

* MultiProvider) Respect the antiquated mechanism for providing `preprocessNode`

There’s certainly code out there that performs a `ko.bindingProvider.instance.preprocessNode = …`

* ko 3.5) Add `childrenComplete`

Cross-link knockout/knockout#2310

* Add `expressionRewriting` to `ko` global for backwards compatibility

* Make `ko.getBindingHandler` an overloadable function

* Prevent infinite recursion with `MultiProvider.instance`

* ci) Fix test wrt tko.bind

* dom/data) Add `getOrSet` function for dom data

* Make the async/component binding completion more explicit

* Make sure the MultiProvider returns an overloaded instances’ new nodes

* Implement details from knockout/knockout#2319

Probably we’ll be ripping all this out since it duplicates what’s in TKO already in terms of async binding handlers (but implementation details aside, this should still pass the KO 3.5 tests)

* Foreach parity re. knockout/knockout#2324

* knockout/knockout#2380 - ko.contextFor after applyBindingAccessorsToNode

* knockout/knockout#2378 Add tests and comply with spec

* knockout/knockout#2379 Fix style binding / compare to prior value

* Fix `arrayFirst` returning `undefined` when found element is falsy

Fixes #63

* Fix `ko.when` for promises & callbacks

* Respect the `createChildContextWithAs` option in the `with` binding

* Respect `createChildContextWithAs` in the native `foreach` binding

* Fix export of extenders

* Fix html parsing regex

* tko.utils) Fix circular reference

* knockout/spec) Update to `master` in KO

* knockout/knockout#2341 Respect `cleanExternalData` overload

@mbest - what do you think of the `addCleaner` and `removeCleaner` API?  Or is that just overkill?

* Binding Provider) Better support for legacy `ko.bindingProvider.instance = …`

* template foreach) Fix the ko.bindingProvider being broke after if this test fails

* Add BindingResult class that exposes binding state

@mbest what do you think of this API?

Do you think `BindingResult` should include the node bound and binding context?  That would be useful for debugging, and open up other useful possibilities - but might be outside the clean, core API.

* apply bindings) Add `rootNode` and `bindingContext` to the BindingResult

* Fix missing comma

* optionsBehaviors) Modify the tests to support lack of `function` support

* applyBindings) call `descendantsComplete` as expected

* tko.bind) Add a special BindingHandler `DescendantBindingHandler`

This should be the superclass of every class that bindings descendants, e.g. `if`, `with`, `foreach`, `template`.

* tko.bind) Add async binding context

This patch should bring parity with #2364, subject to the individual bindings (to be a separate commit)

* tko.bind) Fix error w/ virtual element binding

* tko.bind) Make sure `extend` doesn’t call `valueAccessor(value)`

In tko, `valueAccessor` with a parameter sets the value of the underlying data/observable.  So we pass the value needed for extending an async context by binding the function’s `this`.

* Fix the builder failing to respect `ko.getBindingHandler` setter/getter

Also fix the upstream fix for a custom element tests misssing a `tick` and `template`.

* tko.bind/completion events) Use promises to verify that descendants completed binding

* backers) Update

* utils) Deprecate `proto` utilities, remove circular dependency

1. Fix the subscribable -> dependencyDetection -> … circular dependency
2. Always use `Object.setPrototypeOf`; this introduces a polyfill requirement/dependency for IE9.

* domNodeDisposal) Fix node cleaning test

Updated since merges from master.

* foreach) Fix `$ctx.$index` being overwritten on each update

It’s unusual & unexpected that `_contextExtensions` is being called multiple times; this may be a regression that needs investigation.

* tko.bind) Fix tests re. virtual element error

* tko.bind) Fix circular dependency for `BindingHandler` / `applyBindings`

* tko.bind) Reverting to `descendantsComplete` based on binding promises

@mbest - Note the failing tests and cross-linking #69 and #65.

* binding.template) Update double-unwrap test; disable “destroy” test

Note #69 re. foreachBehaviors.js:131

* util.parser) Skip argument exposure tests in lambdas

Noting for #65.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Projects
None yet
Development

Successfully merging this pull request may close these issues.

None yet

3 participants