Basics

Search…
Basics
Creating Stamps
Stampit gives you several ways to create your stamps (aka factory functions).
NOTE!
Any time you compose - you create a NEW stamp. Every function below always returns a NEW stamp.
Pass plain descriptor
You can pass standard stamp descriptor to stampit.
1
const descriptor = {
2
  methods: ...,
3
  properties: ...,
4
  deepProperties: ...,
5
  propertyDescriptors: ...,
6
  initializers: ...,
7
  staticProperties: ...,
8
  staticDeepProperties: ...,
9
  staticPropertyDescriptors: ...,
10
  composers: ...,
11
  configuration: ...,
12
  deepConfiguration: ...,
13
  name: ...
14
}
15
​
16
const MyStamp = stampit(descriptor) // passing the descriptor
Copied!
Or you can pass stampit-flavoured descriptor (shorter version of the standard descriptor).
1
const shorterDescriptor = {
2
  methods: ...,
3
  props: ...,
4
  deepProps: ...,
5
  propertyDescriptors: ...,
6
  init: ...,
7
  statics: ...,
8
  deepStatics: ...,
9
  staticPropertyDescriptors: ...,
10
  composers: ...,
11
  conf: ...,
12
  deepConf: ...,
13
  name: ...
14
}
15
​
16
const MyStamp = stampit(shorterDescriptor)
Copied!
Shortcut functions
Stampit has 18 shortcut functions attached to it. For example:
1
const { props, methods, init } = stampit
Copied!
You can create stamps from them too.
1
const DefaultFoo = props({ foo: null })
2
const PrintFoo = methods({ printFoo() { console.log(this.foo) } })
3
const PassFoo = init(funciton ({ foo }) { this.foo = foo })
4
​
5
const Foo = DefaultFoo.compose(PrintFoo, PassFoo)
Copied!
The full list of the shortcut functions matches the list of keys you can pass as stamp descriptor (see above).
1
const {     // destructuring
2
  methods,
3
​
4
  props, properties,
5
​
6
  deepProps, deepProperties,
7
​
8
  init, initializers,
9
​
10
  propertyDescriptors,
11
​
12
  statics, staticProperties,
13
​
14
  deepStatics, staticDeepProperties,
15
​
16
  staticPropertyDescriptors,
17
​
18
  conf, configuration,
19
​
20
  deepConf, deepConfiguration,
21
​
22
  composers
23
} = stampit
Copied!
Creating same stamp in few ways
All the examples below create exactly the same stamp.
Classic way
1
const logger = require('bunyan').createLogger({ name: 'log' })
2
​
3
const HasLog = stampit({
4
  properties: {
5
    log: logger
6
  }
7
})
Copied!
Classic way using shorter API
1
const HasLog = stampit({
2
  props: {
3
    log: logger
4
  }
5
})
Copied!
Shortcut way
1
const HasLog = stampit.props({
2
  log: logger
3
})
4
​
5
// OR
6
​
7
const { props } = stampit
8
​
9
const HasLog = props({
10
  log: logger
11
})
Copied!
Composition way
1
const HasLog = stampit().props({
2
  log: logger
3
})
Copied!
Chaining
You can chain all the shortcut functions (see the full list above).
Below is just an example of what you can do. It is a utility stamp. If you compose it to any of your stamps then it will count the number of object instances created from your stamp. Feel free to remove unwanted parts.
InstanceCounter.js
1
const InstanceCounter = stampit()
2
.conf({
3
  instanceCounter: 0 // number of instances of a particular stamp, incremental
4
})
5
.props({
6
  instanceIndex: -1 // an instance number, incremental
7
})
8
.methods({
9
  printInstanceIndex() {
10
    console.log('I am instance #', this.instanceIndex)
11
  } 
12
})
13
.init(function (_, { stamp }) {
14
  this.instanceIndex = stamp.compose.configuration.instanceCounter // instance number
15
  stamp.compose.configuration.instanceCounter += 1 // increment the counter
16
})
17
.staticPropertyDescriptors({ // give the Stamp.name a non-default name. ES6 only.
18
  name: { value: 'InstanceCounter' }
19
})
20
.statics({ 
21
  printTotalInstanceCount() {
22
    console.log(this.compose.configuration.instanceCounter)
23
  } 
24
})
25
.composers(function ({ stamp }) {
26
  // We need to reset the counter each time the InstanceCounter is composed with.
27
  stamp.compose.configuration.instanceCounter = 0
28
})
Copied!
Same InstanceCounter stamp but using the classic stampit way.
InstanceCounter.js
1
const InstanceCounter = stampit({
2
  conf: {
3
    instanceCounter: 0 // number of instances of a particular stamp, incremental
4
  },
5
  props: {
6
    instanceIndex: -1 // an instance number, incremental
7
  },
8
  methods: {
9
    printInstanceIndex() {
10
      console.log('I am instance #', this.instanceIndex)
11
    } 
12
  },
13
  init(_, { stamp }) {
14
    this.instanceIndex = stamp.compose.configuration.instanceCounter // instance number
15
    stamp.compose.configuration.instanceCounter += 1 // increment the counter
16
  },
17
  staticPropertyDescriptors: { // give the Stamp.name a non-default name. ES6 only.
18
    name: { value: 'InstanceCounter' }
19
  },
20
  statics: { 
21
    printTotalInstanceCount() {
22
      console.log(this.compose.configuration.instanceCounter)
23
    } 
24
  },
25
  composers({ stamp }) {
26
    // We need to reset the counter each time the InstanceCounter is composed with.
27
    stamp.compose.configuration.instanceCounter = 0
28
  }
29
});
Copied!
API - Previous
Quick start
Next - API
Methods
Last modified 1yr ago
Copy link
Contents
Creating Stamps
Pass plain descriptor
Shortcut functions
Creating same stamp in few ways
Chaining