flowie/dist/container/createFlowieContainer.js

Library for creating, and working with flows

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const functionConstructors_1 = require("../functionConstructors");
const flowieContainerSignature = Symbol('flowieContainerSignature');
function createFlowieContainer() {
    const flowieContainer = {
        [flowieContainerSignature]: flowieContainerSignature,
        latestDetailsAdded: [],
        allFunctionsNames: new Set(),
        functionsContainer: Object.freeze({}),
        register(...possibleFunctionRegister) {
            return registerFlowFunctionsList({}, ...possibleFunctionRegister);
        },
        merge(...containersOrFunctions) {
            return mergeWithOtherContainerAndFunctions(createFlowieContainer(), ...containersOrFunctions);
        },
        getFunctionDetails() { return null; },
        isAsyncFunction() { return false; }
    };
    return Object.freeze(flowieContainer);
}
exports.default = createFlowieContainer;
function isFlowieContainer(possibleFlowieContainer) {
    return Boolean(possibleFlowieContainer) && flowieContainerSignature in possibleFlowieContainer;
}
exports.isFlowieContainer = isFlowieContainer;
function registerFlowFunctionsList(previousFunctionsContainer, ...possibleFunctionRegister) {
    const initialFunctionRegister = {
        functions: new Map(Object.values(previousFunctionsContainer).map(getFunctionAsKey)),
        functionsDetailsList: []
    };
    const { functionsDetailsList, functions } = possibleFunctionRegister
        .reduce(getUniqueFunctionDetails, initialFunctionRegister);
    const newFunctionsContainer = Object
        .fromEntries(functionsDetailsList.map(getNameAsKey));
    const container = { ...previousFunctionsContainer, ...newFunctionsContainer };
    const latestDetailsAdded = possibleFunctionRegister.map(getFunctionDetail, { functions, container });
    return createContainer(container, latestDetailsAdded);
}
function mergeWithOtherContainerAndFunctions(previousFunctionsContainer, ...containersOrFunctions) {
    return containersOrFunctions.reduce(mergeWithOtherContainerOrRegisterFunctions, previousFunctionsContainer);
}
function getUniqueFunctionDetails(uniqueFunctionsDetails, possibleFunctionRegister) {
    if (Array.isArray(possibleFunctionRegister)) {
        const [name, flowFunction] = possibleFunctionRegister;
        return getFlowFunctionDetailsForTuple(name, flowFunction, uniqueFunctionsDetails);
    }
    if (typeof possibleFunctionRegister === 'function' &&
        !uniqueFunctionsDetails.functions.has(possibleFunctionRegister)) {
        return getFlowFunctionDetailsForFlowFunction(possibleFunctionRegister, uniqueFunctionsDetails);
    }
    return uniqueFunctionsDetails;
}
function getFlowFunctionDetailsForFlowFunction(flowFunction, uniqueFunctionDetails) {
    const name = getNameForFunction(flowFunction);
    const flowFunctionDetailsList = {
        name,
        flowFunction,
        isAsync: functionConstructors_1.isAsyncFunction(flowFunction)
    };
    return incrementUniqueFunctionDetails(uniqueFunctionDetails, [flowFunction, name], flowFunctionDetailsList);
}
function getFlowFunctionDetailsForTuple(name, flowFunction, uniqueFunctions) {
    const isSaved = uniqueFunctions.functions.has(flowFunction);
    const newName = isSaved ? uniqueFunctions.functions.get(flowFunction) : name;
    const flowFunctionDetails = { name, flowFunction, isAsync: functionConstructors_1.isAsyncFunction(flowFunction) };
    return incrementUniqueFunctionDetails(uniqueFunctions, [flowFunction, newName], flowFunctionDetails);
}
function incrementUniqueFunctionDetails(uniqueFunctionDetails, [flowFunction, name], functionsDetails) {
    return {
        functions: new Map([...uniqueFunctionDetails.functions.entries(), [flowFunction, name]]),
        functionsDetailsList: uniqueFunctionDetails.functionsDetailsList.concat(functionsDetails)
    };
}
function mergeWithOtherContainerOrRegisterFunctions(mergedContainer, flowieContainerOrFunction) {
    const flowieContainer = flowieContainerOrFunction;
    if (!isFlowieContainer(flowieContainer)) {
        return mergedContainer.register(flowieContainerOrFunction);
    }
    const container = { ...mergedContainer.functionsContainer, ...flowieContainer.functionsContainer };
    const latestDetailsAdded = mergedContainer.latestDetailsAdded.concat(flowieContainer.latestDetailsAdded);
    return createContainer(container, latestDetailsAdded);
}
function createContainer(functionsContainer, flowFunctionDetailsList) {
    const newFlowieContainer = {
        [flowieContainerSignature]: flowieContainerSignature,
        latestDetailsAdded: flowFunctionDetailsList,
        allFunctionsNames: new Set(Object.keys(functionsContainer)),
        functionsContainer: Object.freeze(functionsContainer),
        register: registerFlowFunctionsList.bind(null, functionsContainer),
        isAsyncFunction(functionName) {
            return functionsContainer[functionName].isAsync;
        },
        getFunctionDetails(functionToFind) {
            return Object.values(functionsContainer).find(matchFlowFunction, { functionToFind });
        }
    };
    const finalContainer = Object.assign({ merge: mergeWithOtherContainerAndFunctions.bind(null, newFlowieContainer) }, newFlowieContainer);
    return Object.freeze(finalContainer);
}
function getNameAsKey(functionDetails) {
    return [functionDetails.name, functionDetails];
}
function getFunctionAsKey(functionDetails) {
    return [functionDetails.flowFunction, functionDetails.name];
}
function getNameForFunction(flowFunction) {
    const randomValue = Math.random().toString(36).slice(2);
    const name = flowFunction.name;
    return name || `anoymous_${randomValue}`;
}
function getFunctionDetail(possibleFunctionRegister) {
    if (Array.isArray(possibleFunctionRegister)) {
        const [, flowFunction] = possibleFunctionRegister;
        return this.container[this.functions.get(flowFunction)];
    }
    return this.container[this.functions.get(possibleFunctionRegister)];
}
function matchFlowFunction(flowFunctionDetailsWithItem) {
    return flowFunctionDetailsWithItem.flowFunction === this.functionToFind;
}
//# sourceMappingURL=createFlowieContainer.js.map