@strapi/utils/dist/provider-factory.mjs

Shared utilities for the Strapi packages

import { cloneDeep } from 'lodash/fp';
import { createAsyncSeriesHook, createAsyncParallelHook } from './hooks.mjs';

/**
 * Creates a new object containing various hooks used by the providers
 */ const createProviderHooksMap = ()=>({
        // Register events
        willRegister: createAsyncSeriesHook(),
        didRegister: createAsyncParallelHook(),
        // Delete events
        willDelete: createAsyncParallelHook(),
        didDelete: createAsyncParallelHook()
    });
/**
 * A Provider factory
 */ const providerFactory = (options = {})=>{
    const { throwOnDuplicates = true } = options;
    const state = {
        hooks: createProviderHooksMap(),
        registry: new Map()
    };
    return {
        hooks: state.hooks,
        async register (key, item) {
            if (throwOnDuplicates && this.has(key)) {
                throw new Error(`Duplicated item key: ${key}`);
            }
            await state.hooks.willRegister.call({
                key,
                value: item
            });
            state.registry.set(key, item);
            await state.hooks.didRegister.call({
                key,
                value: cloneDeep(item)
            });
            return this;
        },
        async delete (key) {
            if (this.has(key)) {
                const item = this.get(key);
                await state.hooks.willDelete.call({
                    key,
                    value: cloneDeep(item)
                });
                state.registry.delete(key);
                await state.hooks.didDelete.call({
                    key,
                    value: cloneDeep(item)
                });
            }
            return this;
        },
        get (key) {
            return state.registry.get(key);
        },
        values () {
            return Array.from(state.registry.values());
        },
        keys () {
            return Array.from(state.registry.keys());
        },
        has (key) {
            return state.registry.has(key);
        },
        size () {
            return state.registry.size;
        },
        async clear () {
            const keys = this.keys();
            for (const key of keys){
                await this.delete(key);
            }
            return this;
        }
    };
};

export { providerFactory as default };
//# sourceMappingURL=provider-factory.mjs.map