Controls collision behavior: forbid or defer

This stamp (aka behavior) will check if there are any conflicts on every compose call. Throws an Error in case of a forbidden collision or ambiguous setup.


import Collision from '@stamp/collision';

const ForbidRedrawCollision = Collision.collisionSetup({forbid: ['redraw']});

Or if you don't want to import the stamp you can import only the method:

import {collisionSetup} from '@stamp/collision';
const ForbidRedrawCollision = collisionSetup({forbid: ['redraw']});

The defer collects same named methods and wraps them into a single method.

import Collision from '@stamp/collision';

import {Border, Button, Graph} from './drawable/primitives';

const UiComponent = Collision.collisionSetup({defer: ['draw']})
.compose(Border, Button, Graph);

const component = UiComponent();
const results = component.draw(); // will draw() all three primitives
console.log(results.length); // prints "3" to the console.

The deferred method returns the array of the values your methods returned. In the example above the results array will have the values the .draw() methods returned.


Static methods


Forbid or Defer an exclusive method stamp.collisionSetup({forbid: ['methodName1'], defer: ['methodName2']}) -> Stamp


Forbid any collisions, excluding those allowed stamp.collisionProtectAnyMethod({allow: ['methoName']}) -> Stamp


Remove any Collision settings from the stamp stamp.collisionSettingsReset() -> Stamp


See the comments in the code:

import compose from '@stamp/compose';
import Collision from '@stamp/collision';
import Privatize from '@stamp/privatize';

// General purpose behavior to defer "draw()" method collisions
const DeferDraw = Collision.collisionSetup({defer: ['draw']});

const Border = compose(DeferDraw, {
  methods: {
    draw: jest.fn() // Spy function
const Button = compose(DeferDraw, {
  methods: {
    draw: jest.fn() // Spy function

// General purpose behavior to privatize the "draw()" method
const PrivateDraw = Privatize.privatizeMethods('draw');

// General purpose behavior to forbid the "redraw()" method collision
const ForbidRedrawCollision = Collision.collisionSetup({forbid: ['redraw']});

// The aggregating component
const ModalDialog = compose(PrivateDraw) // privatize the "draw()" method
  .compose(Border, Button) // modal will consist of Border and Button
  .compose(ForbidRedrawCollision) // there can be only one "redraw()" method
    methods: {
      // the public method which calls the deferred private methods
      redraw(int) {

// Creating an instance of the stamp
const dialog = ModalDialog();

// Check if the "draw()" method is actually privatized

// Calling the public method, which calls the deferred private methods

// Check if the spy "draw()" deferred functions were actually invoked

// Make sure the ModalDialog throws every time on the "redraw()" collisions
const HaveRedraw = compose({methods: {redraw() {}}})
expect(() => compose(ModalDialog, HaveRedraw)).toThrow();

Last updated