di-singleton/build/index.mjs

Wraps a class constructor to ensure only one instance is created, using lazy initialization and optionally calling an init method if present, while maintaining type safety via TypeScript generics.

import crypto from 'crypto';

const isPrimitive = (value) => {
    if (typeof value === "string") {
        return true;
    }
    if (typeof value === "number") {
        return true;
    }
    if (typeof value === "boolean") {
        return true;
    }
    return false;
};
const getHash = (text) => {
    return crypto.createHash("sha256").update(text).digest("hex");
};
const singleton = (ClassCtor) => {
    const instanceMap = new Map();
    const activateInstance = (...args) => {
        if (args.some((value) => !isPrimitive(value))) {
            throw new Error(`di-singleton activateInstance not serializable arguments: ${JSON.stringify(args)}`);
        }
        const instanceKey = getHash(args.join("-"));
        let instance = instanceMap.get(instanceKey);
        if (!instance) {
            instance = new ClassCtor(...args);
            instanceMap.set(instanceKey, instance);
        }
        return instance;
    };
    function ClassActivator(...args) {
        return activateInstance(...args);
    }
    ClassActivator.clear = (...args) => {
        if (args.length) {
            if (args.some((value) => !isPrimitive(value))) {
                throw new Error(`di-singleton ClassActivator.clear not serializable arguments: ${JSON.stringify(args)}`);
            }
            const instanceKey = getHash(args.join("-"));
            instanceMap.delete(instanceKey);
            return;
        }
        instanceMap.clear();
    };
    return ClassActivator;
};

export { singleton };