immer-reducer.ts

import produce, {Draft} from "immer";

let actionTypePrefix = "IMMER_REDUCER";

/** get function arguments as tuple type */
type ArgumentsType<T> = T extends (...args: infer V) => any ? V : never;

/**
 * Get the first value of tuple when the tuple length is 1 otherwise return the
 * whole tuple
 */
type FirstOrAll<T> = T extends [infer V] ? V : T;

/** Get union of function property names */
type FunctionPropertyNames<T> = {
    [K in keyof T]: T[K] extends Function ? K : never;
}[keyof T];

type MethodObject = {[key: string]: () => any};

/** Pick only methods from object */
type Methods<T> = Pick<T, FunctionPropertyNames<T>>;

/** flatten functions in an object to their return values */
type FlattenToReturnTypes<T extends MethodObject> = {
    [K in keyof T]: ReturnType<T[K]>;
};

/** get union of object value types */
type ObjectValueTypes<T> = T[keyof T];

/** get union of object method return types */
type ReturnTypeUnion<T extends MethodObject> = ObjectValueTypes<
    FlattenToReturnTypes<T>
>;

/**
 * Get union of actions types from a ImmerReducer class
 */
export type Actions<T extends ImmerReducerClass> = ReturnTypeUnion<
    ActionCreators<T>
>;

/** type constraint for the ImmerReducer class  */
export interface ImmerReducerClass {
    customName?: string;
    new (...args: any[]): ImmerReducer<any>;
}

/** get state type from a ImmerReducer subclass */
export type ImmerReducerState<T> = T extends {
    prototype: {
        state: infer V;
    };
}
    ? V
    : never;

/** generate reducer function type from the ImmerReducer class */
interface ImmerReducerFunction<T extends ImmerReducerClass> {
    (
        state: ImmerReducerState<T> | undefined,
        action: ReturnTypeUnion<ActionCreators<T>>,
    ): ImmerReducerState<T>;
}

/** ActionCreator function interface with actual action type name */
interface ImmerActionCreator<ActionTypeType, Payload extends any[]> {
    readonly type: ActionTypeType;

    (...args: Payload): {
        type: ActionTypeType;
        payload: FirstOrAll<Payload>;
    };
}

/** generate ActionCreators types from the ImmerReducer class */
export type ActionCreators<ClassActions extends ImmerReducerClass> = {
    [K in keyof Methods<InstanceType<ClassActions>>]: ImmerActionCreator<
        K,
        ArgumentsType<InstanceType<ClassActions>[K]>
    >;
};

/**
 * Internal type for the action
 */
type ImmerAction =
    | {
          type: string;
          payload: unknown;
          args?: false;
      }
    | {
          type: string;
          payload: unknown[];
          args: true;
      };

/**
 * Type guard for detecting actions created by immer reducer
 *
 * @param action any redux action
 * @param immerActionCreator method from a ImmerReducer class
 */
export function isAction<A extends ImmerActionCreator<any, any>>(
    action: {type: any},
    immerActionCreator: A,
): action is ReturnType<A> {
    return action.type === immerActionCreator.type;
}

function isActionFromClass<T extends ImmerReducerClass>(
    action: {type: any},
    immerReducerClass: T,
): action is Actions<T> {
    if (typeof action.type !== "string") {
        return false;
    }

    if (!action.type.startsWith(actionTypePrefix + ":")) {
        return false;
    }

    const [className, methodName] = removePrefix(action.type).split("#");

    if (className !== getReducerName(immerReducerClass)) {
        return false;
    }

    if (typeof immerReducerClass.prototype[methodName] !== "function") {
        return false;
    }

    return true;
}

export function isActionFrom<T extends ImmerReducerClass>(
    action: {type: any},
    immerReducerClass: T,
): action is Actions<T> {
    return isActionFromClass(action, immerReducerClass);
}

/** The actual ImmerReducer class */
export class ImmerReducer<T> {
    static customName?: string;
    readonly state: T;
    draftState: Draft<T>; // Make read only states mutable using Draft

    constructor(draftState: Draft<T>, state: T) {
        this.state = state;
        this.draftState = draftState;
    }
}

function removePrefix(actionType: string) {
    return actionType
        .split(":")
        .slice(1)
        .join(":");
}

let KNOWN_REDUCER_CLASSES: typeof ImmerReducer[] = [];

const DUPLICATE_INCREMENTS: {[name: string]: number | undefined} = {};

/**
 * Set customName for classes automatically if there is multiple reducers
 * classes defined with the same name. This can occur accidentaly when using
 * name mangling with minifiers.
 *
 * @param immerReducerClass
 */
function setCustomNameForDuplicates(immerReducerClass: typeof ImmerReducer) {
    const hasSetCustomName = KNOWN_REDUCER_CLASSES.find(klass =>
        Boolean(klass === immerReducerClass),
    );

    if (hasSetCustomName) {
        return;
    }

    const duplicateCustomName =
        immerReducerClass.customName &&
        KNOWN_REDUCER_CLASSES.find(klass =>
            Boolean(
                klass.customName &&
                    klass.customName === immerReducerClass.customName,
            ),
        );

    if (duplicateCustomName) {
        throw new Error(
            `There is already customName ${immerReducerClass.customName} defined for ${duplicateCustomName.name}`,
        );
    }

    const duplicate = KNOWN_REDUCER_CLASSES.find(
        klass => klass.name === immerReducerClass.name,
    );

    if (duplicate && !duplicate.customName) {
        let number = DUPLICATE_INCREMENTS[immerReducerClass.name];

        if (number) {
            number++;
        } else {
            number = 1;
        }

        DUPLICATE_INCREMENTS[immerReducerClass.name] = number;

        immerReducerClass.customName = immerReducerClass.name + "_" + number;
    }

    KNOWN_REDUCER_CLASSES.push(immerReducerClass);
}

/**
 * Convert function arguments to ImmerAction object
 */
function createImmerAction(type: string, args: unknown[]): ImmerAction {
    if (args.length === 1) {
        return {type, payload: args[0]};
    }

    return {
        type,
        payload: args,
        args: true,
    };
}

/**
 * Get function arguments from the ImmerAction object
 */
function getArgsFromImmerAction(action: ImmerAction): unknown[] {
    if (action.args) {
        return action.payload;
    }

    return [action.payload];
}

export function createActionCreators<T extends ImmerReducerClass>(
    immerReducerClass: T,
): ActionCreators<T> {
    setCustomNameForDuplicates(immerReducerClass);

    const actionCreators: {[key: string]: Function} = {};

    Object.getOwnPropertyNames(immerReducerClass.prototype).forEach(key => {
        if (key === "constructor") {
            return;
        }

        const method = immerReducerClass.prototype[key];

        if (typeof method !== "function") {
            return;
        }

        const type = `${actionTypePrefix}:${getReducerName(
            immerReducerClass,
        )}#${key}`;

        const actionCreator = (...args: any[]) => {
            // Make sure only the arguments are passed to the action object that
            // are defined in the method
            return createImmerAction(type, args.slice(0, method.length));
        };
        actionCreator.type = type;
        actionCreators[key] = actionCreator;
    });

    return actionCreators as any; // typed in the function signature
}

function getReducerName(klass: {name: string; customName?: string}) {
    return klass.customName || klass.name;
}

export function createReducerFunction<T extends ImmerReducerClass>(
    immerReducerClass: T,
    initialState?: ImmerReducerState<T>,
): ImmerReducerFunction<T> {
    setCustomNameForDuplicates(immerReducerClass);

    return function immerReducerFunction(state, action) {
        if (state === undefined) {
            state = initialState;
        }

        if (!isActionFromClass(action, immerReducerClass)) {
            return state;
        }

        if (!state) {
            throw new Error(
                "ImmerReducer does not support undefined state. Pass initial state to createReducerFunction() or createStore()",
            );
        }

        const [_, methodName] = removePrefix(action.type as string).split("#");

        return produce(state, draftState => {
            const reducers: any = new immerReducerClass(draftState, state);

            reducers[methodName](...getArgsFromImmerAction(action as any));

            // The reducer replaced the instance with completely new state so
            // make that to be the next state
            if (reducers.draftState !== draftState) {
                return reducers.draftState;
            }

            // Workaround typing changes in Immer 3.x. This does not actually
            // affect the exposed types by immer-reducer itself.

            // Also using immer internally with anys like this allow us to
            // support multiple versions of immer from 1.4 to 3.x
            return draftState as any;
        });
    };
}

export function setPrefix(prefix: string): void {
    actionTypePrefix = prefix;
}

/**
 * INTERNAL! This is only for tests!
 */
export function _clearKnownClasses() {
    KNOWN_REDUCER_CLASSES = [];
}