[WIP] feat: improve typings

.nvmrc

@@ -0,0 +1 @@
+18.20.4

src/calculateDeepEqualDiffs.js

@@ -1,3 +1,6 @@
+/**
+ * @typedef {import('../types').ObjectDifference} ObjectDifference
+ */
 import {
   isArray,
   isPlainObject,
@@ -20,6 +23,15 @@ const REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;
 const isReactElement = object => object.$$typeof === REACT_ELEMENT_TYPE;
 // end
 
+/**
+ * 
+ * @param {object} a 
+ * @param {object} b 
+ * @param {ObjectDifference[]} diffsAccumulator 
+ * @param {string} pathString 
+ * @param {ObjectDifference[]} diffType 
+ * @returns {boolean}
+ */
 function trackDiff(a, b, diffsAccumulator, pathString, diffType) {
   diffsAccumulator.push({
     diffType,
@@ -36,6 +48,15 @@ function isGetter(obj, prop) {
 
 export const dependenciesMap = new WeakMap();
 
+/**
+ * 
+ * @param {object} a 
+ * @param {object} b 
+ * @param {ObjectDifference[]} diffsAccumulator 
+ * @param {string} pathString 
+ * @param {{ detailed?: boolean }} options 
+ * @returns {boolean}
+ */
 function accumulateDeepEqualDiffs(a, b, diffsAccumulator, pathString = '', { detailed }) {
   if (a === b) {
     if (detailed) {
@@ -197,6 +218,14 @@ function accumulateDeepEqualDiffs(a, b, diffsAccumulator, pathString = '', { det
   return trackDiff(a, b, diffsAccumulator, pathString, diffTypes.different);
 }
 
+/**
+ * 
+ * @param {object} a 
+ * @param {object} b 
+ * @param {string} initialPathString 
+ * @param {{ detailed?: boolean }} options
+ * @returns {ObjectDifference[]}
+ */
 export default function calculateDeepEqualDiffs(a, b, initialPathString, { detailed = false } = {}) {
   try {
     const diffs = [];

src/findObjectsDifferences.js

@@ -1,8 +1,16 @@
-import { reduce } from 'lodash';
+/**
+ * @typedef {import('../types').ObjectDifference} ObjectDifference
+ */
 import calculateDeepEqualDiffs from './calculateDeepEqualDiffs';
 
 const emptyObject = {};
 
+/**
+ * @param {object} userPrevObj 
+ * @param {object} userNextObj 
+ * @param {{ shallow?: boolean }} options
+ * @returns {ObjectDifference[] | false}
+ */
 export default function findObjectsDifferences(userPrevObj, userNextObj, { shallow = true } = {}) {
   if (userPrevObj === userNextObj) {
     return false;
@@ -17,14 +25,10 @@ export default function findObjectsDifferences(userPrevObj, userNextObj, { shall
 
   const keysOfBothObjects = Object.keys({ ...prevObj, ...nextObj });
 
-  return reduce(keysOfBothObjects, (result, key) => {
+  const result = [];
+  for (const key of keysOfBothObjects) {
     const deepEqualDiffs = calculateDeepEqualDiffs(prevObj[key], nextObj[key], key);
-    if (deepEqualDiffs) {
-      result = [
-        ...result,
-        ...deepEqualDiffs,
-      ];
-    }
-    return result;
-  }, []);
+    deepEqualDiffs && result.push(...deepEqualDiffs);
+  }
+  return result;
 }

src/getDisplayName.js

@@ -1,5 +1,8 @@
 import { isString } from 'lodash';
 
+/**
+ * @returns {string}
+ */
 export default function getDisplayName(type) {
   return (
     type.displayName ||

src/getUpdateInfo.js

@@ -1,6 +1,16 @@
+/**
+ * @typedef {import('../types').ObjectDifference} ObjectDifference
+ * @typedef {import('../types').OwnerData} OwnerData
+ * @typedef {import('../types').OwnerDifferences} OwnerDifferences
+ */
 import findObjectsDifferences from './findObjectsDifferences';
 import wdyrStore from './wdyrStore';
 
+/**
+ * 
+ * @param {{ prevOwnerData: OwnerData; nextOwnerData: OwnerData }} param
+ * @returns {OwnerDifferences}
+ */
 function getOwnerDifferences({ prevOwnerData, nextOwnerData }) {
   if (!prevOwnerData || !nextOwnerData) {
     return false;

src/wdyrStore.js

@@ -1,3 +1,7 @@
+/**
+ * @typedef {import('../types').OwnerData} OwnerData
+ */
+
 const wdyrStore = {
   /* The React object we patch */
   React: undefined,
@@ -17,7 +21,10 @@ const wdyrStore = {
   /* A weak map of all React elements to their WDYR patched react elements */
   componentsMap: new WeakMap(),
 
-  /* A weak map of props to the owner element that passed them */
+  /**
+   * A weak map of props to the owner element that passed them.
+   * @type {WeakMap<object, OwnerData>}
+   */
   ownerDataMap: new WeakMap(),
 
   /* An array of hooks tracked during one render */

types.d.ts

@@ -1,16 +1,44 @@
 import * as React from 'react';
 
+export type UpdateDiffType =
+  | 'different'
+  | 'deepEquals'
+  | 'date'
+  | 'regex'
+  | 'reactElement'
+  | 'function'
+  | 'same';
+
+export interface ObjectDifference {
+  pathString: string;
+  diffType: UpdateDiffType;
+  prevValue: any;
+  nextValue: any;
+}
+
 export interface HookDifference {
   pathString: string;
-  diffType: string;
+  diffType: UpdateDiffType;
   prevValue: any;
   nextValue: any;
 }
 
+export interface OwnerHookDifference {
+  hookName: string;
+  differences: ObjectDifference[] | false;
+}
+
+export interface OwnerDifferences {
+  propsDifferences: ObjectDifference[] | false;
+  stateDifferences: ObjectDifference[] | false;
+  hookDifferences: OwnerHookDifference;
+}
+
 export interface ReasonForUpdate {
-  hookDifferences: HookDifference[];
-  propsDifferences: boolean;
-  stateDifferences: boolean;
+  hookDifferences: ObjectDifference[] | false;
+  propsDifferences: ObjectDifference[] | false;
+  stateDifferences: ObjectDifference[] | false;
+  ownerDifferences: OwnerDifferences | false;
 }
 
 export interface UpdateInfo {
@@ -47,14 +75,40 @@ export interface WhyDidYouRenderOptions {
   customName?: string;
 }
 
-export type WhyDidYouRenderComponentMember = WhyDidYouRenderOptions|boolean
+export type WhyDidYouRenderComponentMember = WhyDidYouRenderOptions | boolean;
+
+export type Notifier = (options: UpdateInfo) => void;
 
-export type Notifier = (options: UpdateInfo) => void
+export interface OwnerData {
+  Component: React.ComponentType;
+  displayName: string;
+  props: object;
+  state: object | null;
+  hooks: unknown[];
+  additionalOwnerData?: unknown;
+}
+
+export interface WdyrStore {
+  React: typeof import('react');
+  componentsMap: WeakMap<React.ComponentType, unknown>;
+  hooksPerRender: unknown[];
+  options: WhyDidYouRenderOptions;
+  origCloneElement: typeof React.cloneElement;
+  origCreateElement: typeof React.createElement;
+  origCreateFactory: typeof React.createFactory;
+  ownerDataMap: WeakMap<object, OwnerData>;
+}
 
-declare function whyDidYouRender(react: typeof React, options?: WhyDidYouRenderOptions): typeof React;
+declare function whyDidYouRender(
+  react: typeof React,
+  options?: WhyDidYouRenderOptions
+): typeof React;
 
 declare namespace whyDidYouRender {
   export const defaultNotifier: Notifier;
+  export const wdyrStore: WdyrStore;
+  export const storeOwnerData: unknown;
+  export const getWDYRType: unknown;
 }
 
 export default whyDidYouRender;