fix: types

packages/core/src/editor/query.tsx

@@ -167,12 +167,12 @@ export function QueryMethods(state: EditorState) {
           }
         });
 
-        let childrenNodes = [];
+        let childrenNodes: NodeTree[] = [];
 
         if (reactElement.props && reactElement.props.children) {
           childrenNodes = React.Children.toArray(
             reactElement.props.children
-          ).reduce((accum, child) => {
+          ).reduce<NodeTree[]>((accum, child: any) => {
             if (React.isValidElement(child)) {
               accum.push(_().parseReactElement(child).toNodeTree(normalize));
             }

packages/core/src/editor/store.tsx

@@ -95,6 +95,7 @@ export const useEditorStore = (
     typeof QueryMethods
   >
 ): EditorStore => {
+  // TODO: fix type
   return useMethods(
     ActionMethodsWithConfig,
     {

packages/core/src/editor/useInternalEditor.ts

@@ -1,14 +1,15 @@
 import {
   useCollector,
+  useCollectorReturnType,
   QueryCallbacksFor,
   wrapConnectorHooks,
   ChainableConnectors,
 } from '@craftjs/utils';
-import React, { useContext, useMemo } from 'react';
+import { useContext, useMemo } from 'react';
 
 import { EditorContext } from './EditorContext';
 import { QueryMethods } from './query';
-import { ActionMethodsWithConfig } from './store';
+import { EditorStore } from './store';
 
 import { CoreEventHandlers } from '../events/CoreEventHandlers';
 import { useEventHandler } from '../events/EventContext';
@@ -19,26 +20,23 @@ export type EditorCollector<C> = (
   query: QueryCallbacksFor<typeof QueryMethods>
 ) => C;
 
-export type useInternalEditorReturnType<C = null> = (C extends null
-  ? useCollector<typeof ActionMethodsWithConfig, typeof QueryMethods>
-  : useCollector<typeof ActionMethodsWithConfig, typeof QueryMethods, C>) & {
+export type useInternalEditorReturnType<C = null> = useCollectorReturnType<
+  EditorStore,
+  C
+> & {
   inContext: boolean;
-  store: EditorContext;
+  store: EditorStore;
   connectors: ChainableConnectors<
     CoreEventHandlers['connectors'],
     React.ReactElement
   >;
 };
 
-export function useInternalEditor(): useInternalEditorReturnType;
 export function useInternalEditor<C>(
-  collector: EditorCollector<C>
-): useInternalEditorReturnType<C>;
-export function useInternalEditor<C>(
-  collector?: any
+  collector?: EditorCollector<C>
 ): useInternalEditorReturnType<C> {
   const handlers = useEventHandler();
-  const store = useContext<EditorContext>(EditorContext);
+  const store = useContext(EditorContext);
   const collected = useCollector(store, collector);
 
   const connectors = useMemo(
@@ -47,8 +45,8 @@ export function useInternalEditor<C>(
   );
 
   return {
-    ...(collected as any),
-    connectors: connectors || {},
+    ...collected,
+    connectors,
     inContext: !!store,
     store,
   };

packages/layers/src/manager/LayerManagerProvider.tsx

@@ -2,7 +2,7 @@ import { useMethods } from '@craftjs/utils';
 import React from 'react';
 
 import { LayerMethods } from './actions';
-import { LayerManagerContext } from './context';
+import { LayerManagerContext, LayerStore } from './context';
 
 import { EventManager } from '../events';
 import { LayerOptions } from '../interfaces';
@@ -11,6 +11,7 @@ import { DefaultLayer } from '../layers';
 export const LayerManagerProvider: React.FC<{
   options: Partial<LayerOptions>;
 }> = ({ children, options }) => {
+  // TODO: fix type
   const store = useMethods(LayerMethods, {
     layers: {},
     events: {
@@ -22,7 +23,7 @@ export const LayerManagerProvider: React.FC<{
       renderLayer: DefaultLayer,
       ...options,
     },
-  });
+  }) as LayerStore;
 
   return (
     <LayerManagerContext.Provider value={{ store }}>

packages/layers/src/manager/useLayerManager.tsx

@@ -1,18 +1,17 @@
-import { useCollector } from '@craftjs/utils';
+import { useCollector, useCollectorReturnType } from '@craftjs/utils';
 import { useContext } from 'react';
 
-import { LayerMethods } from './actions';
-import { LayerManagerContext } from './context';
+import { LayerManagerContext, LayerStore } from './context';
 
 import { LayerState } from '../interfaces';
 
-export function useLayerManager(): useCollector<typeof LayerMethods, null>;
+export function useLayerManager(): useCollectorReturnType<LayerStore>;
 export function useLayerManager<C>(
   collector?: (state: LayerState) => C
-): useCollector<typeof LayerMethods, null, C>;
+): useCollectorReturnType<LayerStore, C>;
 export function useLayerManager<C>(
   collector?: (state: LayerState) => C
-): useCollector<typeof LayerMethods, null> {
+): useCollectorReturnType<LayerStore> {
   const { store } = useContext(LayerManagerContext);
   return useCollector(store, collector);
 }

packages/slate/src/extend/slate/SlateNodeContext.tsx

@@ -28,8 +28,8 @@ export const SlateNodeContextProvider: React.FC<SlateNodeContextProviderProps> =
   enabled: initialEnabledValue,
 }) => {
   const { id } = useNode();
-  const [value, setValue] = useState([]);
-  const [enabled, setEnabled] = useState(initialEnabledValue || true);
+  const [value, setValue] = useState<Node[]>([]);
+  const [enabled, setEnabled] = useState<boolean>(initialEnabledValue || true);
 
   const currentEditorSelectionRef = useRef(editor.selection);
   currentEditorSelectionRef.current = editor.selection;

packages/utils/src/EventHandlers/EventHandlers.ts

@@ -4,6 +4,7 @@ import {
   CraftEventListener,
   EventHandlerConnectors,
   CraftDOMEvent,
+  Connector,
 } from './interfaces';
 import { isEventBlockedByDescendant } from './isEventBlockedByDescendant';
 
@@ -74,7 +75,7 @@ export abstract class EventHandlers<O extends Record<string, any> = {}> {
 
   get connectors(): EventHandlerConnectors<this> {
     const connectors = this.handlers();
-    return Object.keys(connectors).reduce(
+    return Object.keys(connectors).reduce<Record<string, Connector>>(
       (accum, connectorName) => ({
         ...accum,
         [connectorName]: (el, required, options) => {

packages/utils/src/useCollector.tsx

@@ -1,53 +1,33 @@
 import { useState, useCallback, useRef, useEffect } from 'react';
 
-import {
-  CallbacksFor,
-  MethodsOrOptions,
-  StateFor,
-  QueryCallbacksFor,
-  QueryMethods,
-  SubscriberAndCallbacksFor,
-} from './useMethods';
+import { SubscriberAndCallbacksFor } from './useMethods';
+import { ConditionallyMergeRecordTypes } from './utilityTypes';
 
-type Actions<M extends MethodsOrOptions, Q extends QueryMethods> = {
-  actions: CallbacksFor<M>;
-  query: QueryCallbacksFor<Q>;
+type CollectorMethods<S extends SubscriberAndCallbacksFor<any, any>> = {
+  actions: S['actions'];
+  query: S['query'];
 };
 
-export type useCollector<
-  M extends MethodsOrOptions,
-  Q extends QueryMethods | null,
+export type useCollectorReturnType<
+  S extends SubscriberAndCallbacksFor<any, any>,
   C = null
-> = C extends null ? Actions<M, Q> : C & Actions<M, Q>;
-
-export function useCollector<
-  M extends MethodsOrOptions,
-  Q extends QueryMethods | null
->(store: SubscriberAndCallbacksFor<M, Q>): useCollector<M, Q>;
-
-export function useCollector<
-  M extends MethodsOrOptions,
-  Q extends QueryMethods | null,
-  C
->(
-  store: SubscriberAndCallbacksFor<M, Q>,
-  collector: (state: StateFor<M>, query: Q) => C
-): useCollector<M, Q, C>;
-
-export function useCollector<
-  M extends MethodsOrOptions,
-  Q extends QueryMethods | null,
-  C
->(store: SubscriberAndCallbacksFor<M, Q>, collector?: any) {
+> = ConditionallyMergeRecordTypes<C, CollectorMethods<S>>;
+export function useCollector<S extends SubscriberAndCallbacksFor<any, any>, C>(
+  store: S,
+  collector?: (
+    state: ReturnType<S['getState']>['current'],
+    query: S['query']
+  ) => C
+): useCollectorReturnType<S, C> {
   const { subscribe, getState, actions, query } = store;
 
   const initial = useRef(true);
-  const collected = useRef<C | null>(null);
+  const collected = useRef<any>(null);
   const collectorRef = useRef(collector);
   collectorRef.current = collector;
 
   const onCollect = useCallback(
-    (collected): useCollector<M, Q, C> => {
+    (collected) => {
       return { ...collected, actions, query };
     },
     [actions, query]

packages/utils/src/useMethods.ts

@@ -71,7 +71,7 @@ export type CallbacksFor<
         >;
       };
     }
-  : never;
+  : {};
 
 export type Methods<S = any, R extends MethodRecordBase<S> = any, Q = any> = (
   state: S,
@@ -131,7 +131,7 @@ export type QueryCallbacksFor<M extends QueryMethods> = M extends QueryMethods<
         canRedo: () => boolean;
       };
     }
-  : never;
+  : {};
 
 export type PatchListenerAction<S, M extends MethodsOrOptions> = {
   type: keyof CallbacksFor<M>;

packages/utils/src/utilityTypes.ts

@@ -3,3 +3,7 @@ export type Delete<T, U> = Pick<T, Exclude<keyof T, U>>;
 export type OverwriteFnReturnType<F extends (...args: any) => void, R> = (
   ...args: Parameters<F>
 ) => Delete<ReturnType<F>, R>;
+export type ConditionallyMergeRecordTypes<
+  C,
+  S extends Record<string, any>
+> = C extends null ? S : C & S;