thesmo-calc-fields-dictionarydeprecated

Summary

This package contains the collection of useful calculating fields for dictionary values.

API

• AddMultipleRecords
• AddRecord
• Initialize
• IsValidDictionary
• ObtainMultipleRecords
• ObtainRecord
• RemoveMultipleRecords
• RemoveRecord
• SearchForKeys
• UpdateWithPattern

API methods clarification

AddMultipleRecords

Signature

/* arguments object */
({
    recordToKey: (record: *) => string,
    newRecords: *[]
})
/* returns */
(source: object) => object

Usage example

const { 
    AddMulipleRecords, 
    Initialize 
} = require("thesmo-calc-fields-dictionary");
const { Create } = require("thesmo-redux-store");

const testStore = Create({});

testStore.To({
    at: "dictionary",
    calcField: Initialize({})
});

testStore.To({
    at: "dictionary",
    calcField: AddMulipleRecords({
        newRecords: [{a: "a1"}, {a: "a2"}, {a: "a3"}],
        recordToKey: (record) => record.a
    })
});

AddRecord

Signature

/* arguments object */
({
    recordToKey: (record: *) => string,
    newRecord: *
})
/* returns */
(source: object) => object

Usage example

const { 
    AddRecord, 
    Initialize 
} = require("thesmo-calc-fields-dictionary");
const { Create } = require("thesmo-redux-store");

const testStore = Create({});

testStore.To({
    at: "dictionary",
    calcField: Initialize({})
});

testStore.To({
    at: "dictionary",
    calcField: AddRecord({
        newRecord: {a: "a1"},
        recordToKey: (record) => record.a
    })
});

Initialize

Signature

/* arguments object */
({
    
})
/* returns */
(source: object) => object

Usage example

const { Initialize } = require("thesmo-calc-fields-dictionary");
const { Create } = require("thesmo-redux-store");

const testStore = Create({});

testStore.To({
    at: "dictionaries.d1",
    calcField: Initialize({})
});

// now this field can be used as Thesmo dictionary

IsValidDictionary

Signature

/* arguments object */
({
    
})
/* returns */
(source: object) => boolean

Usage example

const { 
    Initialize,
    IsValidDictionary
} = require("thesmo-calc-fields-dictionary");
const { Create } = require("thesmo-redux-store");

const testStore = Create({
    defaultState: {
        temp1: { hello: "world" }
    }
});

testStore.To({
    at: "dictionaries.d1",
    calcField: Initialize({})
});

// true
const thesmoDictionaryCheck = testStore.From({
    at: "dictionaries.d1",
    calcField: IsValidDictionary({})
});

// false
const commonObjectCheck = testStore.From({
    at: "temp1",
    calcField: IsValidDictionary({})
});

ObtainMultipleRecords

Signature

/* arguments object */
({
    keys: string[]
})
/* returns */
(source: object) => *[]

Usage example

const CalcFieldsBase = require("thesmo-calc-fields-base");
const DictionaryCalcFields = require("thesmo-calc-fields-dictionary");
const { Create } = require("thesmo-redux-store");

const testStorage = Create({});

const initAndAddMultipleRecords = CalcFieldsBase.Pipe({
    fieldsShouldBePiped: [
        DictionaryCalcFields.Initialize({}),
        DictionaryCalcFields.AddMulipleRecords({
            newRecords: [{a: "a1"}, {a: "a2"}, {a: "a3"}],
            recordToKey: (record) => record.a
        })
    ]
});

testStorage.To({
    at: "dictionary",
    calcField: initAndAddMultipleRecords
});

// [{a: "a1"}, {a: "a3"}]
const a1_a3 = testStorage.From({
    at: "dictionary",
    calcField: DictionaryCalcFields.ObtainMultipleRecords({
        keys: ["a1", "a3"]
    })
});

ObtainRecord

Signature

/* arguments object */
({
    key: string
})
/* returns */
(source: object) => *

Usage example

const CalcFieldsBase = require("thesmo-calc-fields-base");
const DictionaryCalcFields = require("thesmo-calc-fields-dictionary");
const { Create } = require("thesmo-redux-store");

const testStorage = Create({});

const initAndAddMultipleRecords = CalcFieldsBase.Pipe({
    fieldsShouldBePiped: [
        DictionaryCalcFields.Initialize({}),
        DictionaryCalcFields.AddMulipleRecords({
            newRecords: [{a: "a1"}, {a: "a2"}, {a: "a3"}],
            recordToKey: (record) => record.a
        })
    ]
});

testStorage.To({
    at: "dictionary",
    calcField: initAndAddMultipleRecords
});

// {a: "a1"}
const a1 = testStorage.From({
    at: "dictionary",
    calcField: DictionaryCalcFields.ObtainRecord({
        key: "a1"
    })
});

RemoveMultipleRecords

Signature

/* arguments object */
({
    keys: string[]
})
/* returns */
(source: object) => object

Usage example

const CalcFieldsBase = require("thesmo-calc-fields-base");
const DictionaryCalcFields = require("thesmo-calc-fields-dictionary");
const { Create } = require("thesmo-redux-store");

const testStorage = Create({});

const initAndAddMultipleRecords = CalcFieldsBase.Pipe({
    fieldsShouldBePiped: [
        DictionaryCalcFields.Initialize({}),
        DictionaryCalcFields.AddMulipleRecords({
            newRecords: [{a: "a1"}, {a: "a2"}, {a: "a3"}],
            recordToKey: (record) => record.a
        })
    ]
});

testStorage.To({
    at: "dictionary",
    calcField: initAndAddMultipleRecords
});

testStorage.To({
    at: "dictionary",
    calcField: DictionaryCalcFields.RemoveMultipleRecords({
        keys: ["a1", "a3"]
    })
});

RemoveRecord

Signature

/* arguments object */
({
    key: string
})
/* returns */
(source: object) => object

Usage example

const CalcFieldsBase = require("thesmo-calc-fields-base");
const DictionaryCalcFields = require("thesmo-calc-fields-dictionary");
const { Create } = require("thesmo-redux-store");

const testStorage = Create({});

const initAndAddMultipleRecords = CalcFieldsBase.Pipe({
    fieldsShouldBePiped: [
        DictionaryCalcFields.Initialize({}),
        DictionaryCalcFields.AddMulipleRecords({
            newRecords: [{a: "a1"}, {a: "a2"}, {a: "a3"}],
            recordToKey: (record) => record.a
        })
    ]
});

testStorage.To({
    at: "dictionary",
    calcField: initAndAddMultipleRecords
});

testStorage.To({
    at: "dictionary",
    calcField: DictionaryCalcFields.RemoveRecord({
        key: "a3"
    })
});

SearchForKeys

Signature

/* arguments object */
({
    searchParameters?: (index: number, key: string, record: *) => boolean
})
/* returns */
(source: object) => string[]

Usage example

const CalcFieldsBase = require("thesmo-calc-fields-base");
const DictionaryCalcFields = require("thesmo-calc-fields-dictionary");
const { Create } = require("thesmo-redux-store");

const testStorage = Create({});

const initAndAddMultipleRecords = CalcFieldsBase.Pipe({
    fieldsShouldBePiped: [
        DictionaryCalcFields.Initialize({}),
        DictionaryCalcFields.AddMulipleRecords({
            newRecords: [{a: "a1"}, {a: "a2"}, {a: "a3"}],
            recordToKey: (record) => record.a
        })
    ]
});

testStorage.To({
    at: "dictionary",
    calcField: initAndAddMultipleRecords
});

// ["a1", "a2", "a3"]
const allKeys = testStorage.From({
    at: "dictionary",
    calcField: DictionaryCalcFields.SearchForKeys({})
});

// ["a1", "a3"]
const specificKeys = testStorage.From({
    at: "dictionary",
    calcField: DictionaryCalcFields.SearchForKeys({
        searchParameters: function(index, key, record) {
            return index === 0 || key === "a3";
        }
    })
});

UpdateWithPattern

Signature

/* arguments object */
({
    isAbleToAddNewRecords?: boolean,
    updatingPattern: object
})
/* returns */
(source: object) => object

Usage example

const CalcFieldsBase = require("thesmo-calc-fields-base");
const DictionaryCalcFields = require("thesmo-calc-fields-dictionary");
const ThesmoReduxStore = require("thesmo-redux-store");

const testStorage = ThesmoReduxStore.Create({});

const initializeDictionary = DictionaryCalcFields.Initialize({});
const addDummyRecords = DictionaryCalcFields.AddMulipleRecords({
    newRecords: [{a: "a1"}, {a: "a2"}, {a: "a3"}, {a: "a4"}],
    recordToKey: source => source.a
});
const updateDictionary = DictionaryCalcFields.UpdateWithPattern({
    isAbleToAddNewRecords: true,
    updatingPattern: {
        a1: x => {return { ...x, a: x.a + "_modified" } },
        a5: {a: 55},
        a6: {aaa: 11}
    }
});

const allFields = [
    initializeDictionary, 
    addDummyRecords, 
    updateDictionary
];

testStorage.To({
    at: "d",
    calcField: CalcFieldsBase.Pipe({
        fieldsShouldBePiped: allFields
    })
});