feat(connectTo): pass target instance to selector

[doktordirk]

Allows selectors to be based on the target instance's state

Example:

interface Item {
  value: string;
}

interface State {
   items: Record<string, Item>;
}

@connectTo({
   selector: (state: State, itemView: ItemView) => pipe(map(state => state.items[itemView.id])),
   target: 'item',
})
export class ItemView {
  @bindable id: string;
  item: Item;
}

[zewa666]

could you elaborate a bit on the use case of this? in your example it sounds like you want to dynamically decide the state prop based on instance values. what would be the purpose of doing so?

[doktordirk]

hmm seems basic to me to only bind an index

<message repeat.for="id of messageIds"></message>

and maybe an editor

<message-editor id="messageId"></message-editor>

I'm not keen ton passing large object around

[zewa666]

not sure I get that one. you want to use the provided binding to determine the dynamic key which to use as your projections target inside messageEditor?

besides relying on exact order of bind/attached could turn out to be unstable when using the instance. may I ask you for a little bit kore concrete example?

[doktordirk]

Let's say i have a main/details view and then in the details view

activate(parameters) {
    this.messageId = parameters.messageId;
}

To get the message data there or in a sub-component on atm would have to do

bind() {
  this.subscribtion = this.store.state
   .pipe(
     pluck('messages'),
     map(messages => messages[this.messageId])
  ).subscribe(message => {
     this.message = message;
 });
}

unbind() {
  this.subscribtion.unsubscribe();
}

with the proposed change, one can do instead

@connectTo({
   message: (store: Store<MessageState>, messageDetails: MessageDetails) => store.state
     .pipe(
        pluck('messages'),
        map(messages => messages[messageDetails.messageId])
     )
})
class MessageDetails {
...

as for being potentially unreliable: Dunno, certainly exactly as reliable as the 'manual' version above. Given the bind order is defined here, the order also be the same. You see any potential issues there? In both versions, one could eg use map(messages => messageDetails.messageId] ?? messages[messageDetails.messageId]) .
Whatever issues there might be, it wouldn't be specific to using the target instance in connectTo