GitBook: [master] 41 pages and 2 assets modified

Author: koresar

.gitbook/assets/class_vs_stamp (1).png

@@ -1,26 +1,28 @@
-# What is stampit
+# Introduction
 
-`stampit` is a JavaScript module which implements the [**stamp** specification](https://www.gitbook.com/book/stampit-org/docs/edit#). **Stamps** are composable factory functions.
+## What is stampit
+
+`stampit` is a JavaScript module which implements the [**stamp** specification](essentials/specification/). **Stamps** are composable factory functions.
 
 **Think of **_**stamps**_** as classic classes but without any limits, boundaries, or rules.**
 
 The stamps brag large amount of features and things you can do with your objects and/or stamps.
 
-Head straight to the [Quick Start](/start.md) page for code examples.
+Head straight to the [Quick Start](api/quick-start.md) page for code examples.
 
-![](/assets/class_vs_stamp.png)
+![](.gitbook/assets/class_vs_stamp%20%281%29.png)
 
-# Differences from classes
+## Differences from classes
 
 * Inheritance
   * Classes
     * Classes do child+parent+parent+parent... inheritance chains. See picture above.
     * When you extend a class you link class prototypes.
   * Stamps
     * Stamp are single object + single prototype. See picture above.
-    * When you "extend" you separately merge [methods](/methods.md), separately merge [properties](/properties.md), separately merge [static properties](/static-properties.md), separately merge [initializers](/initializers.md) \(aka constructors\), etc etc etc.
-    * That's why it is not just inheritance, but special type of object composition. The stamp composition algorithm is [standardized](/specification/merging-algorithm.md).
-    * You can influence composition result with your code at runtime using the [composers](/composers.md) feature.
+    * When you "extend" you separately merge [methods](https://github.com/stampit-org/docs/tree/cb1b11dcef3e3b0b3aa5212adcf9047a2f882b06/methods.md), separately merge [properties](https://github.com/stampit-org/docs/tree/cb1b11dcef3e3b0b3aa5212adcf9047a2f882b06/properties.md), separately merge [static properties](https://github.com/stampit-org/docs/tree/cb1b11dcef3e3b0b3aa5212adcf9047a2f882b06/static-properties.md), separately merge [initializers](https://github.com/stampit-org/docs/tree/cb1b11dcef3e3b0b3aa5212adcf9047a2f882b06/initializers.md) \(aka constructors\), etc etc etc.
+    * That's why it is not just inheritance, but special type of object composition. The stamp composition algorithm is [standardized](essentials/specification/merging-algorithm.md).
+    * You can influence composition result with your code at runtime using the [composers](https://github.com/stampit-org/docs/tree/cb1b11dcef3e3b0b3aa5212adcf9047a2f882b06/composers.md) feature.
 * Object creation
   * Classes
     * In most programming languages you execute only one constructor per class.
@@ -30,19 +32,19 @@ Head straight to the [Quick Start](/start.md) page for code examples.
     * Stamp executes every initializer \(aka constructor\) it has.
     * All initializers receive exactly the same set of arguments, no need to manually pass data.
     * The initializer execution sequence is the same as the stamp composition sequence.
-    * To create an object you [call stamp](/start.md) as a function: `const object = MyStamp()`.
+    * To create an object you [call stamp](https://github.com/stampit-org/docs/tree/cb1b11dcef3e3b0b3aa5212adcf9047a2f882b06/start.md) as a function: `const object = MyStamp()`.
 
-# History
+## History
 
-The original idea of Stamps belongs to [Eric Elliott](https://ericelliottjs.com/). See his [first commit](https://github.com/stampit-org/stampit/commit/ac330e8537e349a9640bbe4a34c63150db445a20) from 11 Feb 2013 in the stampit repository. Since then the idea evolved to the [specification](/specification.md) and a whole [ecosystem](/ecosystem.md) of mini modules.
+The original idea of Stamps belongs to [Eric Elliott](https://ericelliottjs.com/). See his [first commit](https://github.com/stampit-org/stampit/commit/ac330e8537e349a9640bbe4a34c63150db445a20) from 11 Feb 2013 in the stampit repository. Since then the idea evolved to the [specification](https://github.com/stampit-org/docs/tree/cb1b11dcef3e3b0b3aa5212adcf9047a2f882b06/specification.md) and a whole [ecosystem](https://github.com/stampit-org/docs/tree/cb1b11dcef3e3b0b3aa5212adcf9047a2f882b06/ecosystem.md) of mini modules.
 
-# Using Stamps
+## Using Stamps
 
-Head straight to the [Quick start](/start.md) for code examples.
+Head straight to the [Quick start](https://github.com/stampit-org/docs/tree/cb1b11dcef3e3b0b3aa5212adcf9047a2f882b06/start.md) for code examples.
 
-# Ecosystem
+## Ecosystem
 
 Stampit have a lot of helper modules. You can always find the list of official NPM packages here: [https://www.npmjs.com/~stamp](https://www.npmjs.com/~stamp)
 
-See more information on the [Ecosystem](/ecosystem.md) page.
+See more information on the [Ecosystem](https://github.com/stampit-org/docs/tree/cb1b11dcef3e3b0b3aa5212adcf9047a2f882b06/ecosystem.md) page.
 

.gitbook/assets/class_vs_stamp.png

@@ -1,18 +1,20 @@
-# Summary
+# Table of contents
+
+* [Introduction](README.md)
 
 ## Essentials
 
-* [Overview](README.md)
-* [What is a Stamp](descriptor.md)
-* [Installation](installation.md)
-* [Specification](specification/README.md)
-  * [Merging algorithm](specification/merging-algorithm.md)
-  * [Object creation internals](specification/object-creation-internals.md)
-* [FAQ](faq.md)
+* [Overview](essentials/overview.md)
+* [What is a Stamp](essentials/what-is-a-stamp.md)
+* [Installation](essentials/installation.md)
+* [Specification](essentials/specification/README.md)
+  * [Merging algorithm](essentials/specification/merging-algorithm.md)
+  * [Object creation internals](essentials/specification/object-creation-internals.md)
+* [FAQ](essentials/faq.md)
 
 ## API
 
-* [Quick start](api/README.md)
+* [Quick start](api/quick-start.md)
 * [Basics](api/basics.md)
 * [Methods](api/methods.md)
 * [Properties](api/properties.md)
@@ -28,10 +30,10 @@
 
 ## Ecosystem
 
-* [Ecosystem Overview](ecosystem/README.md)
-* [@stamp/collision](ecosystem/stampcollision.md)
-* [@stamp/required](ecosystem/stamprequired.md)
-* [@stamp/privatize](ecosystem/stampprivatize.md)
-* [@stamp/named](ecosystem/stampnamed.md)
-* [@stamp/instanceof](ecosystem/stampinstanceof.md)
+* [Ecosystem Overview](ecosystem/ecosystem-overview.md)
+* [@stamp/collision](ecosystem/stamp-collision.md)
+* [@stamp/required](ecosystem/stamp-required.md)
+* [@stamp/privatize](ecosystem/stamp-privatize.md)
+* [@stamp/named](ecosystem/stamp-named.md)
+* [@stamp/instanceof](ecosystem/stamp-instanceof.md)
 

README.md

@@ -10,9 +10,9 @@ Stampit gives you several ways to create your objects.
 
 ### Pass plain descriptor
 
-You can pass standard [stamp descriptor](/composition.md) to stampit.
+You can pass standard [stamp descriptor](https://github.com/stampit-org/docs/tree/cb1b11dcef3e3b0b3aa5212adcf9047a2f882b06/composition.md) to stampit.
 
-```js
+```javascript
 const descriptor = {
   methods: ...,
   properties: ...,
@@ -32,7 +32,7 @@ const MyStamp = stampit(descriptor) // passing the descriptor
 
 Or you can pass _sampit-flavoured_ descriptor \(shorter version of the standard descriptor\).
 
-```js
+```javascript
 const shorterDescriptor = {
   methods: ...,
   props: ...,
@@ -54,13 +54,13 @@ const MyStamp = stampit(shorterDescriptor)
 
 Stampit has 18 shortcut functions attached to it. For example:
 
-```js
+```javascript
 const { props, methods, init } = stampit
 ```
 
 You can create stamps from them too.
 
-```js
+```javascript
 const DefaultFoo = props({ foo: null })
 const PrintFoo = methods({ printFoo() { console.log(this.foo) } })
 const PassFoo = init({ foo }) { this.foo = foo })
@@ -70,7 +70,7 @@ const Foo = DefaultFoo.compose(PrintFoo, PassFoo)
 
 The full list of the shortcut functions matches the list of keys you can pass as stamp descriptor \(see above\).
 
-```js
+```javascript
 const {     // destructuring
   methods,
 
@@ -102,7 +102,7 @@ All the examples below create _exactly the same stamp_.
 
 #### Classic way
 
-```js
+```javascript
 const logger = require('bunyan').createLogger({ name: 'log' })
 
 const HasLog = stampit({
@@ -114,7 +114,7 @@ const HasLog = stampit({
 
 #### Classic way using shorter API
 
-```js
+```javascript
 const HasLog = stampit({
   props: {
     log: logger
@@ -124,7 +124,7 @@ const HasLog = stampit({
 
 #### Shortcut way
 
-```js
+```javascript
 const HasLog = stampit.props({
   log: logger
 })
@@ -140,7 +140,7 @@ const HasLog = props({
 
 #### Composition way
 
-```js
+```javascript
 const HasLog = stampit().props({
   log: logger
 })
@@ -150,7 +150,7 @@ const HasLog = stampit().props({
 
 You can chain all the shortcut functions \(see the full list above\).
 
-```js
+```javascript
 const InstanceCounter = stampit()
 .conf({
   instanceCounter: 0 // number of instances of a particular stamp

SUMMARY.md

@@ -6,7 +6,7 @@ Composers are callback functions executed each time a composition happens. There
 
 It is highly recommended to **not create new stamps** in the composers, but **mutate the given stamp** if necessary.
 
-```js
+```javascript
 const InstanceOf = stampit.composers(({ stamp, composables }) => {
   if (!stamp.compose.methods) stamp.compose.methods = {} // mutating stamp
   stamp.compose.methods.getStamp = () => stamp           // mutating stamp
@@ -33,13 +33,13 @@ The above `InstanceOf` stamp overrides the default `instanceof` behavior using E
 
 > NOTE
 >
-> You can find the stamp above as the [`@stamp/instanceof`](/stampinstanceof.md) NPM module.
+> You can find the stamp above as the [`@stamp/instanceof`](https://github.com/stampit-org/docs/tree/cb1b11dcef3e3b0b3aa5212adcf9047a2f882b06/stampinstanceof.md) NPM module.
 
 ## Descriptor merging algorithm
 
 The composers are concatenated into a deduplicated array. As the result, the order of composition becomes **the order of composer execution**.
 
-```js
+```javascript
 const {composers} = stampit
 
 const Log1 = composers(() => console.log(1))
@@ -59,7 +59,7 @@ MultiLog.compose.composers.length === 3
 
 Stamps remove duplicate composers.
 
-```js
+```javascript
 const {composers} = stampit
 
 const func = () => console.log(1)
@@ -87,7 +87,7 @@ Every composer always receive this object: `{ stamp, composables }`. Where:
 
 Exactly the same stamp can be created in few ways. Here they all are.
 
-```js
+```javascript
 function myDebugComposer ({ stamp, composables }) {
   console.log(`Stamp ${stamp} was composed of ${composables}`)
 }
@@ -107,5 +107,3 @@ const Logger = stampit().composers(myDebugComposer)
 const Logger = stampit().composers([myDebugComposer])
 ```
 
-
-

api/basics.md

@@ -2,7 +2,7 @@
 
 Configuration is a storage of an arbitrary data in the `.configuration` metadata of stamp's descriptor.
 
-```js
+```javascript
 let HaveApiKey = stampit({
   conf: {
     apiKey: process.env.API_KEY
@@ -12,9 +12,9 @@ let HaveApiKey = stampit({
 HaveApiKey.compose.configuration.apiKey === process.env.API_KEY
 ```
 
-You can set configuration in [static methods](/static-properties.md):
+You can set configuration in [static methods](https://github.com/stampit-org/docs/tree/cb1b11dcef3e3b0b3aa5212adcf9047a2f882b06/static-properties.md):
 
-```js
+```javascript
 HaveApiKey = HaveApiKey.statics({
   setApiKey(key) {
     return this.conf({ apiKey: key }) // create new stamp by composing parent stamp with some configuration
@@ -26,9 +26,9 @@ HaveApiKey = HaveApiKey.setApiKey('abcd1234')
 HaveApiKey.compose.configuration.apiKey === 'abcd1234'
 ```
 
-You can access the configuration in stamp [initializers](/initializers.md) \(aka constructors\).
+You can access the configuration in stamp [initializers](https://github.com/stampit-org/docs/tree/cb1b11dcef3e3b0b3aa5212adcf9047a2f882b06/initializers.md) \(aka constructors\).
 
-```js
+```javascript
 const ApiKeyPrinter = HaveApiKey.init(function (opts, { stamp }) {
   const configuration = stamp.compose.configuration
 
@@ -42,7 +42,7 @@ HaveApiKey() // this will execute the initializer, and will print "abcd1234" to
 
 The configuration properties are copied **by assignment**. In other words - **by reference **using `Object.assign`.
 
-```js
+```javascript
 HaveApiKey.compose.configuration.apiKey === ApiKeyPrinter.compose.configuration.apiKey
 ```
 
@@ -52,7 +52,7 @@ In case of conflicts the last composed property wins.
 
 Exactly the same stamp can be created in few ways. Here they all are.
 
-```js
+```javascript
 const HasLog = stampit({
   conf: {
     apiKey: process.env.API_KEY
@@ -82,5 +82,3 @@ const HasLog = stampit().configuration({
 })
 ```
 
-
-

api/composers.md

@@ -1,8 +1,8 @@
-# Deep Configuration
+# Deep configuration
 
-Deep Configuration is a storage of an arbitrary data in the `.deepConfiguration` metadata of stamp's descriptor. But unlike regular \(shallow\) configuration these are deeply merged together by stamp [deep merging algorithm](/specification/merging-algorithm.md).
+Deep Configuration is a storage of an arbitrary data in the `.deepConfiguration` metadata of stamp's descriptor. But unlike regular \(shallow\) configuration these are deeply merged together by stamp [deep merging algorithm](../essentials/specification/merging-algorithm.md).
 
-```js
+```javascript
 let Kue = stampit.deepConf({
   Kue: {
     name: 'kue',
@@ -26,9 +26,9 @@ MyKue.compose.deepConfiguration.Kue.attempts === 3
 MyKue.compose.deepConfiguration.Kue.priority === 'high'
 ```
 
-You can set deep configuration in [static methods](/static-properties.md):
+You can set deep configuration in [static methods](https://github.com/stampit-org/docs/tree/cb1b11dcef3e3b0b3aa5212adcf9047a2f882b06/static-properties.md):
 
-```js
+```javascript
 Kue = Kue.statics({
   configureKue(options) {
     return this.deepConf({Kue: options}) // create new stamp by composing parent stamp with some configuration
@@ -45,9 +45,9 @@ Kue = Kue.statics({
 const MyRegularJobKue = Kue.attempts(5).delay(1000).ttl(10).events(true).priority('low')
 ```
 
-You can access the configuration in stamp [initializers](/initializers.md) \(aka constructors\).
+You can access the configuration in stamp [initializers](https://github.com/stampit-org/docs/tree/cb1b11dcef3e3b0b3aa5212adcf9047a2f882b06/initializers.md) \(aka constructors\).
 
-```js
+```javascript
 Kue = Kue.init(function (payload, { stamp }) {
   const conf = stamp.compose.deepConfiguration.Kue
   this.conf = conf
@@ -65,17 +65,17 @@ myKue.put({ title: 'Vasyl Boroviak', email: '[email protected]', template: 'welc
 
 ## Descriptor merging algorithm
 
-The deepConfiguration is **deeply merged** using stamp [deep merging algorithm](/specification/merging-algorithm.md). See below - the `Kue` value is always a new object.
+The deepConfiguration is **deeply merged** using stamp [deep merging algorithm](../essentials/specification/merging-algorithm.md). See below - the `Kue` value is always a new object.
 
-```js
+```javascript
 Kue.compose.deepConfiguration.Kue !== MyKue.compose.deepConfiguration.Kue // NEVER EQUAL! NO MATTER WHAT!
 ```
 
 ## Other ways to add deep configuration
 
 Exactly the same stamp can be created in few ways. Here they all are.
 
-```js
+```javascript
 const myKueConf = { Kue: { priority: 'normal' } }
 
 const AuthServiceToken = stampit({
@@ -107,5 +107,3 @@ const HasLog = stampit().deepConfiguration({
 })
 ```
 
-
-