import { createContext, createComponent, useContext, type JSX, type Context, type FlowComponent, } from "solid-js"; import type { ContextProviderComponent } from "../node_modules/solid-js/types/reactive/signal.js"; export type ContextProviderProps = { children?: JSX.Element; } & Record; export type ContextProvider = ( props: { children: JSX.Element } & T, ) => JSX.Element; /** * Create the Context Provider component and useContext function with types inferred from the factory function. * @param factoryFn Factory function will run when the provider component in executed. It takes the provider component `props` as it's argument, and what it returns will be available in the contexts for all the underlying components. * @param defaults fallback returned from useContext function if the context wasn't provided * @returns tuple of `[provider component, useContext function]` * @example * ```tsx * const [CounterProvider, useCounter] = createContextProvider((props: { initial: number }) => { * const [count, setCount] = createSignal(props.initial); * const increment = () => setCount(count() + 1) * return { count, increment }; * }); * // Provide the context * * * * // get the context * const ctx = useCounter() * ctx?.count() // => 1 * ``` */ export function createContextProvider( factoryFn: (props: P) => T, defaults: T, ): [provider: ContextProvider

, useContext: () => T]; export function createContextProvider( factoryFn: (props: P) => T, ): [provider: ContextProvider

, useContext: () => T | undefined]; export function createContextProvider( factoryFn: (props: P) => T, defaults?: T, ): [provider: ContextProvider

, useContext: () => T | undefined] { const ctx = createContext(defaults); return [ props => { return createComponent(ctx.Provider, { value: factoryFn(props), get children() { return props.children; }, }); }, () => useContext(ctx), ]; } /* MultiProvider inspired by the preact-multi-provider package from Marvin Hagemeister See https://github.com/marvinhagemeister/preact-multi-provider Type validation of the `values` array thanks to the amazing @otonashixav (https://github.com/otonashixav) */ /** * A component that allows you to provide multiple contexts at once. It will work exactly like nesting multiple providers as separate components, but it will save you from the nesting. * * @param values Array of tuples of `[ContextProviderComponent, value]` or `[Context, value]` or bound `ContextProviderComponent` (that doesn't take a `value` property). * * @example * ```tsx * // before * * * * * * * // after * * * * ``` */ export function MultiProvider(props: { values: { [K in keyof T]: | readonly [ Context | ContextProviderComponent, [T[K]][T extends unknown ? 0 : never], ] | FlowComponent; }; children: JSX.Element; }): JSX.Element { const { values } = props; const fn = (i: number) => { let item: any = values[i]; if (!item) return props.children; const ctxProps: { value?: any; children: JSX.Element } = { get children() { return fn(i + 1); }, }; if (Array.isArray(item)) { ctxProps.value = item[1]; item = item[0]; if (typeof item !== "function") item = item.Provider; } return createComponent(item, ctxProps); }; return fn(0); }