Add type definitions for recoil

types/recoil/index.d.ts

@@ -0,0 +1,29 @@
+// Type definitions for recoil 0.0
+// Project: https://github.com/facebookexperimental/recoil#readme
+// Definitions by: Christian Santos <https://github.com/csantos42>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// Minimum TypeScript Version: 3.7
+
+// Nominal Classes
+export { DefaultValue } from './lib/core/node';
+
+// Components
+export { RecoilRoot } from './lib/core/RecoilRoot';
+
+// Recoil state
+export { atom } from './lib/core/atom';
+export { selector } from './lib/core/selector';
+
+// Hooks
+export {
+    useRecoilValue,
+    useRecoilValueLoadable,
+    useRecoilState,
+    useRecoilStateLoadable,
+    useSetRecoilState,
+    useResetRecoilState,
+    useRecoilCallback,
+} from './lib/core/hooks';
+
+// Other
+export { isRecoilValue } from './lib/core/recoilValue';

types/recoil/lib/core/RecoilRoot.d.ts

@@ -0,0 +1,11 @@
+import { FC } from 'react';
+import { RecoilState } from './recoilValue';
+
+export interface RecoilRootProps {
+    initializeState?: (options: {
+        set: <T>(recoilVal: RecoilState<T>, newVal: T) => void;
+        setUnvalidatedAtomValues: (atomMap: Map<string, unknown>) => void;
+    }) => void;
+}
+
+export const RecoilRoot: FC<RecoilRootProps>;

types/recoil/lib/core/atom.d.ts

@@ -0,0 +1,11 @@
+import { NodeKey } from './state';
+import { RecoilValue, RecoilState } from './recoilValue';
+
+export type AtomOptions<T> = Readonly<{
+    key: NodeKey;
+    default: RecoilValue<T> | Promise<T> | T;
+    // persistence_UNSTABLE?: PersistenceSettings<T>,
+    dangerouslyAllowMutability?: boolean;
+}>;
+
+export function atom<T>(options: AtomOptions<T>): RecoilState<T>;

types/recoil/lib/core/hooks.d.ts

@@ -0,0 +1,22 @@
+import { RecoilValue, RecoilState } from './recoilValue';
+import { Loadable } from './loadable';
+
+export type SetterOrUpdater<T> = (valOrUpdater: ((currVal: T) => T) | T) => void;
+export type Resetter = () => void;
+export type CallbackInterface = Readonly<{
+    getPromise: <T>(recoilVal: RecoilValue<T>) => Promise<T>;
+    getLoadable: <T>(recoilVal: RecoilValue<T>) => Loadable<T>;
+    set: <T>(recoilVal: RecoilState<T>, valOrUpdater: ((currVal: T) => T) | T) => void;
+    reset: (recoilVal: RecoilState<any>) => void;
+}>;
+
+export function useRecoilValue<T>(recoilValue: RecoilValue<T>): T;
+export function useRecoilValueLoadable<T>(recoilValue: RecoilValue<T>): Loadable<T>;
+export function useRecoilState<T>(recoilState: RecoilState<T>): [T, SetterOrUpdater<T>];
+export function useRecoilStateLoadable<T>(recoilState: RecoilState<T>): [Loadable<T>, SetterOrUpdater<T>];
+export function useSetRecoilState<T>(recoilState: RecoilState<T>): SetterOrUpdater<T>;
+export function useResetRecoilState(recoilState: RecoilState<any>): Resetter;
+export function useRecoilCallback<Args extends ReadonlyArray<unknown>, Return>(
+    fn: (interface: CallbackInterface, ...args: Args) => Return,
+    deps?: ReadonlyArray<unknown>,
+): (...args: Args) => Return;

types/recoil/lib/core/loadable.d.ts

@@ -0,0 +1,37 @@
+import { TreeState } from './state';
+
+export type ResolvedLoadablePromiseInfo<T> = Readonly<{
+    value: T;
+    upstreamState__INTERNAL_DO_NOT_USE?: TreeState;
+}>;
+
+export type LoadablePromise<T> = Promise<ResolvedLoadablePromiseInfo<T>>;
+
+export type Accessors<T> = Readonly<{
+    // Attempt to get the value.
+    // If there's an error, throw an error.  If it's still loading, throw a Promise
+    // This is useful for composing with React Suspense or in a Recoil Selector.
+    getValue: () => T;
+
+    toPromise: () => LoadablePromise<T>;
+
+    // Convenience accessors
+    valueMaybe: () => T | void;
+    valueOrThrow: () => T;
+    errorMaybe: () => Error | void;
+    errorOrThrow: () => Error;
+    promiseMaybe: () => Promise<T> | void;
+    promiseOrThrow: () => Promise<T>;
+
+    map: <S>(map: (val: any) => Promise<S> | S) => Loadable<S>;
+}>;
+
+export type Loadable<T> =
+    | Readonly<Accessors<T> & { state: 'hasValue'; contents: T }>
+    | Readonly<Accessors<T> & { state: 'hasError'; contents: Error }>
+    | Readonly<
+          Accessors<T> & {
+              state: 'loading';
+              contents: LoadablePromise<T>;
+          }
+      >;

types/recoil/lib/core/node.d.ts

@@ -0,0 +1 @@
+export class DefaultValue {}

types/recoil/lib/core/recoilValue.d.ts

@@ -0,0 +1,21 @@
+import { NodeKey } from './state';
+
+export class AbstractRecoilValue<T> {
+    tag: 'Writeable';
+    key: NodeKey;
+    constructor(newKey: NodeKey);
+}
+
+export class AbstractRecoilValueReadonly<T> {
+    tag: 'Readonly';
+    key: NodeKey;
+    constructor(newKey: NodeKey);
+}
+
+export class RecoilState<T> extends AbstractRecoilValue<T> {}
+
+export class RecoilValueReadOnly<T> extends AbstractRecoilValueReadonly<T> {}
+
+export type RecoilValue<T> = RecoilValueReadOnly<T> | RecoilState<T>;
+
+export function isRecoilValue(val: unknown): val is RecoilValue<any>;

types/recoil/lib/core/selector.d.ts

@@ -0,0 +1,32 @@
+import { RecoilValue, RecoilState, RecoilValueReadOnly } from './recoilValue';
+import { DefaultValue } from './node';
+
+export type GetRecoilValue = <T>(recoilVal: RecoilValue<T>) => T;
+export type SetRecoilState = <T>(
+    recoilVal: RecoilState<T>,
+    newVal: T | DefaultValue | ((prevValue: T) => T | DefaultValue),
+) => void;
+
+export type ResetRecoilState = (recoilVal: RecoilState<any>) => void;
+
+export interface ReadOnlySelectorOptions<T> {
+    key: string;
+    get: (opts: { get: GetRecoilValue }) => Promise<T> | RecoilValue<T> | T;
+
+    // cacheImplementation_UNSTABLE?: CacheImplementation<Loadable<T>>,
+    dangerouslyAllowMutability?: boolean;
+}
+
+export type ReadWriteSelectorOptions<T> = ReadOnlySelectorOptions<T> & {
+    set: (
+        opts: {
+            set: SetRecoilState;
+            get: GetRecoilValue;
+            reset: ResetRecoilState;
+        },
+        newValue: T | DefaultValue,
+    ) => void;
+};
+
+export function selector<T>(options: ReadWriteSelectorOptions<T>): RecoilState<T>;
+export function selector<T>(options: ReadOnlySelectorOptions<T>): RecoilValueReadOnly<T>;

types/recoil/lib/core/state.d.ts

@@ -0,0 +1,23 @@
+import { Loadable } from './loadable';
+
+export type NodeKey = string;
+export type AtomValues = Map<NodeKey, Loadable<any>>;
+export type ComponentCallback = (state: TreeState) => void;
+export type TreeState = Readonly<{
+    // Information about the TreeState itself:
+    isSnapshot: boolean;
+    transactionMetadata: object;
+    dirtyAtoms: Set<NodeKey>;
+
+    // ATOMS
+    atomValues: AtomValues;
+    nonvalidatedAtoms: Map<NodeKey, unknown>;
+
+    // NODE GRAPH -- will soon move to StoreState
+    // Upstream Node dependencies
+    nodeDeps: Map<NodeKey, Set<NodeKey>>;
+
+    // Downstream Node subscriptions
+    nodeToNodeSubscriptions: Map<NodeKey, Set<NodeKey>>;
+    nodeToComponentSubscriptions: Map<NodeKey, Map<number, [string, ComponentCallback]>>;
+}>;

types/recoil/recoil-tests.ts

@@ -0,0 +1,124 @@
+import {
+    DefaultValue,
+    RecoilRoot,
+    atom,
+    selector,
+    useRecoilValue,
+    useRecoilValueLoadable,
+    useRecoilState,
+    useRecoilStateLoadable,
+    useSetRecoilState,
+    useResetRecoilState,
+    useRecoilCallback,
+    isRecoilValue,
+} from 'recoil';
+// import { atomFamily } from 'recoil/utils';
+
+// DefaultValue
+new DefaultValue();
+
+// atom
+const myAtom = atom({
+    key: 'asds',
+    default: 5,
+});
+
+// selector
+const mySelector1 = selector({
+    key: 'asdfasfds',
+    get: () => 5,
+});
+
+const readOnlySelector = selector({
+    key: 'asdfasf',
+    get: ({ get }) => {
+        get(myAtom) + 10;
+        get(mySelector1);
+        get(5); // $ExpectError
+    },
+});
+
+const writeableSelector = selector({
+    key: 'asdfsadfs',
+    get: ({ get }) => {
+        get(mySelector1) + 10;
+    },
+    set: ({ get, set, reset }) => {
+        get(myAtom);
+        set(myAtom, 5);
+        reset(myAtom);
+
+        set(readOnlySelector, 2); // $ExpectError
+        reset(readOnlySelector); // $ExpectError
+    },
+});
+
+// RecoilRoot
+RecoilRoot({});
+RecoilRoot({
+    initializeState: ({ set, setUnvalidatedAtomValues }) => {
+        set(myAtom, 5);
+        setUnvalidatedAtomValues(new Map());
+
+        set(readOnlySelector, 2); // $ExpectError
+        setUnvalidatedAtomValues({}); // $ExpectError
+    },
+});
+
+// Hooks
+useRecoilValue(myAtom);
+useRecoilValue(mySelector1);
+useRecoilValue(readOnlySelector);
+useRecoilValue(writeableSelector);
+useRecoilValue({}); // $ExpectError
+
+useRecoilValueLoadable(myAtom);
+useRecoilValueLoadable(readOnlySelector);
+useRecoilValueLoadable(writeableSelector);
+useRecoilValueLoadable({}); // $ExpectError
+
+useRecoilState(myAtom);
+useRecoilState(writeableSelector);
+useRecoilState(readOnlySelector); // $ExpectError
+useRecoilState({}); // $ExpectError
+
+useRecoilStateLoadable(myAtom);
+useRecoilStateLoadable(writeableSelector);
+useRecoilStateLoadable(readOnlySelector); // $ExpectError
+useRecoilStateLoadable({}); // $ExpectError
+
+useSetRecoilState(myAtom);
+useSetRecoilState(writeableSelector);
+useSetRecoilState(readOnlySelector); // $ExpectError
+useSetRecoilState({}); // $ExpectError
+
+useResetRecoilState(myAtom);
+useResetRecoilState(writeableSelector);
+useResetRecoilState(readOnlySelector); // $ExpectError
+useResetRecoilState({}); // $ExpectError
+
+useRecoilCallback(async ({ getPromise, getLoadable, set, reset }) => {
+    const val: number = await getPromise(mySelector1);
+    const loadable = getLoadable(mySelector1);
+
+    loadable.getValue();
+    loadable.toPromise();
+    loadable.state;
+
+    set(myAtom, 5);
+    reset(myAtom);
+});
+
+// Other
+isRecoilValue(4);
+isRecoilValue(myAtom);
+isRecoilValue(null);
+isRecoilValue(mySelector1);
+
+// UTILS
+
+// atomFamily
+// atomFamily({
+//     key: 'asdfs',
+//     default: (a) => {return ''},
+// });

types/recoil/tsconfig.json

@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictFunctionTypes": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "recoil-tests.ts"
+    ]
+}

types/recoil/tslint.json

@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }