# @stamp/it

Utility belt implementation of the compose standard

This module is the new cool modern version of the stampit module. Consider @stamp/it as stampit v4.

Usage

Install:

1$ npm i -S @stamp/it 

Import:

1import stampit from '@stamp/it'

Or import utility functions only:

1import {
2    methods,
3    
4    props,
5    properties,
6    
7    statics,
8    staticProperties,
9    
10    conf,
11    configuration,
12    
13    deepProps,
14    deepProperties,
15    
16    deepStatics,
17    staticDeepProperties,
18    
19    deepConf,
20    deepConfiguration,
21    
22    init,
23    initializers,
24    
25    composers,
26    
27    propertyDescriptors,
28    
29    staticPropertyDescriptors
30} from '@stamp/it'
31
32const Stamp1 = methods({ foo() {} })
33const Stamp2 = props({ bar: 'my bar' })
34const Stamp3 = conf({ my: 'configuration' })
35const Stamp4 = init(function (options, {stamp, instance, args}) {
36  console.log('bla')
37})

API

Arguments

See more examples in this blog post.

Create a new empty stamp:

1const S1 = stampit()

Create a new stamp with a method:

1const S2 = stampit({
2  methods: {
3    myMethod() { }
4  }
5})

Create a new stamp with a property:

1const S3 = stampit({
2  props: { // or properties:
3    myProperty: 42
4  }
5})

Create a new stamp with a static property:

1const S4 = stampit({
2  statics: { // or staticProperties:
3    myStaticProperty: 42
4  }
5})

Create a new stamp with initializer(s):

1const S5 = stampit({
2  init: function () { console.log('hi form initializer') }
3})
4// or
5const S6 = stampit({
6  init: [ // or initializers:
7    function () { },
8    function () { }
9  ]
10})

Create a new stamp with a configuration:

1const S7 = stampit({
2  conf: { // or configuration:
3    myConfiguration: { anything: 'here' }
4  }
5})

Compose the stamps above together:

1const Stamp = compose(S1, S2, S3, S4, S5, S6, S7)
2console.log(Stamp)
3// { compose: [function] { properties, methods, staticProperties, initializers, configuration } }
4
5const obj = Stamp()
6console.log(obj)
7// { myProperty: 42 }
8console.log(Object.getPrototypeOf(obj))
9// { myMethod: [function] }

See more examples in this blog post.

Static methods

The Stamp.create() static method

Calling Stamp.create() is identical to calling Stamp().

Shortcut static methods

All stamps receive few static properties. These are taken from the @stamp/shortcut stamp. For example:

1stampit()
2  .props({ foo: 'foo' })
3  .deepConf({ things: ['bar'] })
4  .methods({ baz() {} })
5  // etc

Shortcut exported methods

The module exports a range of shortcut methods. These are taken from the @stamp/shortcut stamp.

1import {methods, props, init, statics, /* etc */} from '@stamp/it'

Each returns a stampit-flavoured stamp.

NOTE! Unlike the @stamp/shortcut module, all the exported functions of @stamp/it are stampit-flavoured. Meaning that:

1import {methods} from '@stamp/it'
2const Stamp = methods({ foo() {} })
3.props({bar: 1})                    // THIS WILL WORK
4.statics({baz: 2})                  // AND THIS WILL WORK TOO