Extends ImmutableJS Records enabling class inheritance
Dependencies
Getting Started
npm install imumo --save
Usage
; // Define getters to expose easy access to properties { return this; } { return true; } { return true; } // create synthetic properties { return thisvaluelength; } // override default values { return this; } { return thisvaluelength !== 0; } { return typeof thisvalue === 'string'; } // 'Mutable' methods should all return a new immutable instance { return this; } { return super && /^[^@]+@[^\.]+\.$/; } { return this; } { return this; } { return typeof thisvalue === "number"; } { return this; } { return thisunits ? ` ` : thisvalue; } const bobsEmail = value: 'bob@gmail.com';console; // trueconsole; // falseconsole; // true -- bobsEmail has not been mutated const myBank = units: 'dollars';console; // 0 dollarsconst myBankAfterDreamOfWinningLotto = myBank;console; // 100000000 dollarsconsole; // 0 dollars -- myBank was not mutated :(
Performance
Since the models are immutable, we can store memoized results of method calls on our model instances. Since memoization is stored on the instance, any mutations will invalidate the cache and gargabe collection comes for free. This lets you write expensive getters without having to worry too much about the performance impact. This also allows you to use strict equality checking against derived data (Pure render all the views).
Note: Since the constructor is only run when new
is called, you need to put your memoizers in the didCreateInstance
lifecycle hook.
Note: Memoization uses strict equality to check for matches, so passing in a new instance of an Immutable List, for example, will not be memoized. Remember to set the cache size if you think there will be a large number or unique calls.
;; { thisgetUnreadEmails = ; thisgetEmailsFromUser = ; } { return this; } { return thisemails; } { return thisemails; } const inbox = ;console; // trueconsole; // true
Methods ImmutableModel
Signatures using flow notation [functionName]([arg] : [argType]) : [returnType]
. Note that T
denotes either the same instance or a new instance of the same type. ImmutableModels create new instances with the same type whenever a mutation occurs.
signature | description |
---|---|
didCreateInstance() |
Lifecycle method called after new instance is made (due to 'mutation') |
toString(): String |
Returns string representation of model |
get(key: String, notSetVal: any): any |
Gets value by key if exists, otherwise returns notSetVal |
clear(): T |
Returns self or new T without any values in backing Map |
set(key: String, val: any): T |
Returns self or new T with key set to value |
remove(key: String): T |
Returns self or new T with value at key removed |
removeIn(keyPath: Array<any>): T |
Returns self or new T with value at keypath removed |
merge() |
see Map.merge() |
mergeWith() |
see Map.mergeWith() |
mergeIn() |
see Map.mergeIn() |
mergeDeep() |
see Map.mergeDeep() |
mergeDeepWith() |
see Map.mergeDeepWith() |
mergeDeepIn() |
see Map.mergeDeepIn() |
setIn() |
see Map.setIn() |
update() |
see Map.update() |
updateIn() |
see Map.updateIn() |
withMutations() |
see Map.withMutations() |
asMutable() |
see Map.asMutable() |
asImmutable() |
see Map.asImmutable() |
Many methods are duplicates/copies of Immutable Map methods, which have more thorough documentation and examples.
Credits
- ImmutableJS for underlying data structures
- npm-starter
- Airbnb for the work they've put into the javascript style guide and into the ESlint package.
License
MIT @ Joe Delgado