vue-atoms/dist/index.js

Better type-safe provide() and inject() for Vue

"use strict";
var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
    if (kind === "m") throw new TypeError("Private method is not writable");
    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
};
var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var _Store_supportsWeakMap, _Store_store;
Object.defineProperty(exports, "__esModule", { value: true });
exports.useAtom = exports.provideAtom = exports.injectAtom = exports.provide = exports.inject = exports.atom = void 0;
const vue_1 = require("vue");
/**
 * This uses a WeakMap where it is valid, and falls back to a Map.
 * To do so, we need to trick TypeScript into thinking that we're
 * only using a Map, as it doesn't support WeakMap using symbol keys.
 */
class Store {
    constructor() {
        _Store_supportsWeakMap.set(this, void 0);
        _Store_store.set(this, void 0);
        try {
            const wm = new WeakMap();
            // eslint-disable-next-line symbol-description
            wm.set(Symbol(), 0);
            __classPrivateFieldSet(this, _Store_supportsWeakMap, true, "f");
            __classPrivateFieldSet(this, _Store_store, wm, "f");
        }
        catch (e) {
            __classPrivateFieldSet(this, _Store_supportsWeakMap, false, "f");
            __classPrivateFieldSet(this, _Store_store, new Map(), "f");
        }
    }
    set(key, value) {
        __classPrivateFieldGet(this, _Store_store, "f").set(key, value);
    }
    get(key) {
        return __classPrivateFieldGet(this, _Store_store, "f").get(key);
    }
    has(key) {
        return __classPrivateFieldGet(this, _Store_store, "f").has(key);
    }
    delete(key) {
        __classPrivateFieldGet(this, _Store_store, "f").delete(key);
    }
}
_Store_supportsWeakMap = new WeakMap(), _Store_store = new WeakMap();
const store = new Store();
const atom = (initialValue) => {
    const sym = Symbol('atom');
    store.set(sym, initialValue);
    return sym;
};
exports.atom = atom;
const isAtom = (key) => {
    return typeof key !== 'string' && store.has(key);
};
function inject(key, defaultValue, treatDefaultAsFactory) {
    const unique = Symbol.for('unique-injection');
    if (isAtom(key)) {
        if (defaultValue !== undefined) {
            throw new Error('Cannot inject atoms with default values. Atoms already have default values.');
        }
        if ((0, vue_1.hasInjectionContext)()) {
            const tryValue = (0, vue_1.inject)(key, unique);
            if (tryValue !== undefined && tryValue !== unique) {
                return tryValue;
            }
        }
        return store.get(key);
    }
    else {
        // @ts-expect-error - The types are right, but TS doesn't like it
        return (0, vue_1.inject)(key, defaultValue, treatDefaultAsFactory);
    }
}
exports.inject = inject;
function provide(key, value) {
    if (isAtom(key)) {
        /** Create a new atom with the same type */
        const val = (0, exports.atom)(value);
        (0, vue_1.provide)(key, store.get(val));
    }
    else {
        (0, vue_1.provide)(key, value);
    }
}
exports.provide = provide;
/** Type-restricted functions */
const injectAtom = (atm) => inject(atm);
exports.injectAtom = injectAtom;
exports.useAtom = exports.injectAtom;
const provideAtom = (atm, value) => {
    provide(atm, value);
};
exports.provideAtom = provideAtom;