feat(signals): port from vCurrent

README.md

@@ -73,6 +73,7 @@ An experimental re-working of Aurelia, oriented around compile-time reflection a
   * [x] `debounce`
   * [x] `throttle`
   * [x] `updateTrigger`
+  * [x] `signal`
   * [x] `self`
 * Template Controllers
   * [x] `if`

src/debug/reporter.ts

@@ -93,5 +93,13 @@ const codeLookup: Record<string, IMessageInfo> = {
   10: {
     type: MessageType.error,
     message: 'The updateTrigger binding behavior can only be applied to two-way/ from-view bindings on input/select elements.'
+  },
+  11: {
+    type: MessageType.error,
+    message: 'Only property bindings and string interpolation bindings can be signaled. Trigger, delegate and call bindings cannot be signaled.'
+  },
+  12: {
+    type: MessageType.error,
+    message: 'Signal name is required.'
   }
 };

src/runtime/configuration/standard.ts

@@ -17,6 +17,7 @@ import { SelfBindingBehavior } from "../resources/self-binding-behavior";
 import { ThrottleBindingBehavior } from "../resources/throttle-binding-behavior";
 import { UpdateTriggerBindingBehavior } from "../resources/update-trigger-binding-behavior";
 import { With } from "../resources/with";
+import { ISignaler, Signaler, SignalBindingBehavior } from "../resources/signals";
 
 export const StandardConfiguration = {
   register(container: IContainer) {
@@ -32,6 +33,7 @@ export const StandardConfiguration = {
       DebounceBindingBehavior,
       ThrottleBindingBehavior,
       UpdateTriggerBindingBehavior,
+      SignalBindingBehavior,
       SelfBindingBehavior,
 
       // Template Controllers
@@ -51,5 +53,6 @@ export const StandardConfiguration = {
     container.register(Registration.instance(IObserverLocator, ObserverLocator));
     container.register(Registration.instance(IAnimator, Animator));
     container.register(Registration.instance(ISanitizer, Sanitizer));
+    container.register(Registration.instance(ISignaler, Signaler));
   }
 };

src/runtime/resources/signals.ts

@@ -0,0 +1,95 @@
+import { sourceContext, IScope } from '../binding/binding-context';
+import { DI } from '../di';
+import { IBinding, Binding } from '../binding/binding';
+import { ICallable } from '../interfaces';
+import { bindingBehavior } from '../decorators';
+import { Reporter } from '../reporter';
+
+type Signal = string;
+
+export const ISignaler = DI.createInterface('ISignaler');
+
+export interface ISignaler {
+  dispatchSignal(name: Signal): void;
+  addSignalListener(name: Signal, listener: ICallable): void;
+  removeSignalListener(name: Signal, listener: ICallable): void;
+}
+
+const signals: Record<Signal, ICallable[]> = {};
+
+export const Signaler: ISignaler = {
+  dispatchSignal(name: Signal): void {
+    let bindings = signals[name];
+
+    if (!bindings) {
+      return;
+    }
+
+    let i = bindings.length;
+
+    while (i--) {
+      bindings[i].call(sourceContext);
+    }
+  },
+
+  addSignalListener(name: Signal, listener: ICallable) {
+    (signals[name] || (signals[name] = [])).push(listener);
+  },
+
+  removeSignalListener(name: Signal, listener: ICallable) {
+    let listeners = signals[name];
+
+    if (listeners) {
+      listeners.splice(listeners.indexOf(listener), 1);
+    }
+  }
+}
+
+type SignalableBinding = Binding & {
+  signal: string | string[];
+};
+
+@bindingBehavior('signal')
+export class SignalBindingBehavior {
+  signals;
+
+  bind(binding: SignalableBinding, scope: IScope) {
+    if (!binding.updateTarget) {
+      throw Reporter.error(11);
+    }
+
+    if (arguments.length === 3) {
+      let name = arguments[2];
+      Signaler.addSignalListener(name, binding);
+      binding.signal = name;
+    } else if (arguments.length > 3) {
+      let names = Array.prototype.slice.call(arguments, 2);
+      let i = names.length;
+
+      while (i--) {
+        let name = names[i];
+        Signaler.addSignalListener(name, binding);
+      }
+
+      binding.signal = names;
+    } else {
+      throw Reporter.error(12);
+    }
+  }
+
+  unbind(binding: SignalableBinding, scope: IScope) {
+    let name = binding.signal;
+    binding.signal = null;
+
+    if (Array.isArray(name)) {
+      let names = name;
+      let i = names.length;
+
+      while (i--) {
+        Signaler.removeSignalListener(names[i], binding);
+      }
+    } else {
+      Signaler.removeSignalListener(name, binding);
+    }
+  }
+}