react-obsidian 2.11.0 → 3.0.0-alpha.1

package/src/decorators/Graph.ts

@@ -1,4 +1,4 @@
-import { Constructable } from '../types';
+import { Constructable, type Constructor } from '../types';
 import 'reflect-metadata';
 import graphRegistry from '../graph/registry/GraphRegistry';
 import { ObjectGraph } from '../graph/ObjectGraph';
@@ -7,9 +7,9 @@ interface GraphParams {
   subgraphs: Constructable<ObjectGraph>[];
 }
 
-export function Graph({ subgraphs = [] }: Partial<GraphParams> = {}) {
-  return (constructor: any) => {
-    graphRegistry.register(constructor, subgraphs);
-    return constructor;
+export function graph<Class extends Constructor>({ subgraphs = [] }: Partial<GraphParams> = {}) {
+  return (Clazz: Class) => {
+    graphRegistry.register(Clazz, subgraphs);
+    return Clazz;
   };
 }

package/src/decorators/LifecycleBound.ts

@@ -2,7 +2,7 @@ type Options = {
   scope?: 'component' | 'feature';
 };
 
-export function LifecycleBound(options?: Options) {
+export function lifecycleBound(options?: Options) {
   return (constructor: any) => {
     Reflect.defineMetadata('isLifecycleBound', true, constructor);
     Reflect.defineMetadata('lifecycleScope', options?.scope ?? 'feature', constructor);

package/src/decorators/Memoize.ts

@@ -1,18 +1,13 @@
-/* eslint-disable no-param-reassign */
 import 'reflect-metadata';
 
-export default function Memoize() {
-  return function provide(_Clazz: any, propertyKey: string, descriptor: PropertyDescriptor) {
-    const originalGet = descriptor.get!;
-    descriptor.get = function get() {
-      const key = `memoized${propertyKey}`;
-      if (Reflect.hasMetadata(key, this)) {
-        return Reflect.getMetadata(key, this);
-      }
-      const value = originalGet.call(this);
-      Reflect.defineMetadata(key, value, this);
-      return value;
-    };
-    return descriptor;
-  };
+export default function memoize<This, Return>(
+  target: (this: This) => Return,
+  context: ClassGetterDecoratorContext,
+) {
+  function memoizer(this: This): Return {
+    const value = target.call(this);
+    Object.defineProperty(this, context.name, { value, enumerable: true });
+    return value;
+  }
+  return memoizer;
 }

package/src/decorators/Singleton.ts

@@ -1,14 +1,25 @@
-import { Constructable } from '../types';
-import { ObjectGraph } from '../graph/ObjectGraph';
-
-export function Singleton() {
+export function singleton() {
   return function singleton(
-    constructorOrGraph: Constructable<ObjectGraph> | ObjectGraph,
-    _property?: string,
-    descriptor?: PropertyDescriptor,
-  ): any {
-    const target = descriptor || constructorOrGraph;
+    target: any, // Class extends Constructor || (this: This, ...args: Args) => Return
+  ) {
     Reflect.defineMetadata('isSingleton', true, target);
     return target;
+
+    // return function singleton(
+    //   constructorOrGraph: Constructable<ObjectGraph> | ObjectGraph,
+    //   _property?: string,
+    //   descriptor?: PropertyDescriptor,
+    // ): any {
+    //   const target = descriptor || constructorOrGraph;
+    //   Reflect.defineMetadata('isSingleton', true, target);
+    //   return target;
+    // };
   };
 }
+
+// function methodSingleton<This, Args extends any[], Return>(
+//   target: (this: This, ...args: Args) => Return,
+// ) {
+//   Reflect.defineMetadata('isSingleton', true, target);
+//   return target;
+// }

package/src/decorators/inject/Inject.ts

@@ -1,17 +1,17 @@
-import { isNumber } from '../../utils/isNumber';
 import InjectionMetadata from '../../injectors/class/InjectionMetadata';
 
-export function Inject(name?: string) {
+export function inject<This, Return>(name?: string) {
   return (
-    target: Object | any,
-    _propertyKey?: string,
-    indexOrPropertyDescriptor?: number | PropertyDescriptor,
+    _target: undefined,
+    context: ClassFieldDecoratorContext<This, Return>,
   ) => {
-    const metadata = new InjectionMetadata();
-    if (isNumber(indexOrPropertyDescriptor)) {
-      metadata.saveConstructorParamMetadata(target, name!, indexOrPropertyDescriptor);
-    } else {
-      metadata.savePropertyMetadata(target.constructor, name!);
-    }
+    context.addInitializer(function (this: This) {
+      const metadata = new InjectionMetadata();
+      metadata.savePropertyMetadata((this as object).constructor, name!);
+    });
+
+    return function (this: This, value: Return) {
+      return value;
+    };
   };
 }

package/src/decorators/inject/Injectable.ts

@@ -3,6 +3,6 @@ import { Graph } from '../../graph/Graph';
 import graphRegistry from '../../graph/registry/GraphRegistry';
 import ClassInjector from '../../injectors/class/ClassInjector';
 
-export function Injectable(Graph: Constructable<Graph>): any {
+export function injectable(Graph: Constructable<Graph>): any {
   return new ClassInjector(graphRegistry).inject(Graph);
 }

package/src/decorators/inject/LateInject.ts

@@ -1,8 +1,13 @@
 import InjectionMetadata from '../../injectors/class/InjectionMetadata';
 
-export function LateInject(name?: string): any {
-  return (target: object) => {
-    const metadata = new InjectionMetadata();
-    metadata.saveLatePropertyMetadata(target.constructor, name!);
+export function lateInject<This, Value>(name?: string): any {
+  return (
+    _target: undefined,
+    context: ClassFieldDecoratorContext<This, Value>,
+  ) => {
+    context.addInitializer(function (this: This) {
+      const metadata = new InjectionMetadata();
+      metadata.saveLatePropertyMetadata((this as object).constructor, name!);
+    });
   };
 }

package/src/decorators/provides/MemoizeDescriptor.ts

@@ -1,4 +1,3 @@
-/* eslint-disable no-param-reassign */
 export function memoizeDescriptor(propertyKey: string, descriptor: PropertyDescriptor): PropertyDescriptor {
   const originalValue = descriptor.value;
   descriptor.value = function value(...args: any[]) {

package/src/decorators/provides/Provides.ts

@@ -1,14 +1,33 @@
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 import { Graph } from '../../graph/Graph';
 import providedPropertiesStore from '../../ProvidedPropertiesStore';
-import { memoizeDescriptor } from './MemoizeDescriptor';
 
 interface ProvidesParams {
   name: string;
 }
 
-export function Provides({ name }: Partial<ProvidesParams> = {}) {
-  return function provide(graph: Graph, propertyKey: string, descriptor: PropertyDescriptor) {
-    providedPropertiesStore.set(graph, propertyKey, name!);
-    return memoizeDescriptor(propertyKey, descriptor);
+export function provides<This, Args extends any[], Return>({ name }: Partial<ProvidesParams> = {}) {
+  return function (
+    target: (this: This, ...args: Args) => Return,
+    context: ClassMethodDecoratorContext<This, (this: This, ...args: Args) => Return>,
+  ) {
+    context.addInitializer(function (this: This) {
+      const mangledProperty = String(context.name);
+      // @ts-ignore
+      this[mangledProperty] = this[mangledProperty].bind(this);
+      providedPropertiesStore.set(this as Graph, mangledProperty, name!);
+    });
+
+    function replacementMethod(this: This, ...args: Args): Return {
+      const memoizedResult = Reflect.get(this as object, `memoized${name!}`);
+      if (memoizedResult === undefined) {
+        const result = target.call(this, ...args);
+        Reflect.set(this as object, `memoized${name!}`, result);
+        return result;
+      }
+      return memoizedResult;
+    }
+
+    return replacementMethod;
   };
 }

package/src/graph/ObjectGraph.ts

@@ -1,5 +1,5 @@
 import { uniqueId } from '../utils/uniqueId';
-import Memoize from '../decorators/Memoize';
+import memoize from '../decorators/Memoize';
 import { bindProviders } from './ProviderBinder';
 import { Graph } from './Graph';
 import PropertyRetriever from './PropertyRetriever';
@@ -9,7 +9,7 @@ import { CircularDependenciesDetector } from './CircularDependenciesDetector';
 export abstract class ObjectGraph<T = unknown> implements Graph {
   private propertyRetriever = new PropertyRetriever(this);
 
-  @Memoize()
+  @memoize
   get name(): string {
     return uniqueId(this.constructor.name);
   }
@@ -26,13 +26,11 @@ export abstract class ObjectGraph<T = unknown> implements Graph {
     return this.propertyRetriever.retrieve(property, receiver, detector) as Dependency | undefined;
   }
 
-  onBind(_target: any) {
-
-  }
+  onBind(_target: any) { void 0; }
 }
 
 Reflect.set(ObjectGraph, 'typeDiscriminator', 'ObjectGraph');
 
-export function isGraph(object: Constructable<ObjectGraph> | any): object is Constructable<ObjectGraph> {
+export function isGraph(object: any): object is Constructable<ObjectGraph> {
   return Reflect.get(object, 'typeDiscriminator') === 'ObjectGraph';
 }

package/src/graph/PropertyRetriever.ts

@@ -10,7 +10,7 @@ export default class PropertyRetriever {
     property: string,
     receiver?: unknown,
     maybeDetector?: CircularDependenciesDetector,
-  ): unknown | undefined {
+  ): unknown {
     const mangledPropertyKey = providedPropertiesStore.getMangledProperty(this.graph, property);
     const circularDependenciesDetector = maybeDetector ?? new CircularDependenciesDetector(this.graph.name);
 
@@ -32,8 +32,8 @@ export default class PropertyRetriever {
     if (circularDependenciesDetector.hasCircularDependencies()) {
       throw new Error(
         `Could not resolve ${circularDependenciesDetector.firstDependencyName}`
-         + ` from ${circularDependenciesDetector.graphName} because of a circular dependency:`
-         + ` ${circularDependenciesDetector.getDependencies().join(' -> ')}`,
+        + ` from ${circularDependenciesDetector.graphName} because of a circular dependency:`
+        + ` ${circularDependenciesDetector.getDependencies().join(' -> ')}`,
       );
     }
 
@@ -56,6 +56,6 @@ export default class PropertyRetriever {
     const subgraphs = graphRegistry.getSubgraphs(this.graph);
     return subgraphs
       .map((subgraph: Graph) => subgraph.retrieve(property, receiver, circularDependenciesDetector))
-      .filter((result) => result !== undefined);
+      .filter(result => result !== undefined);
   }
 }

package/src/graph/PropertyRetrieverDelegate.ts

@@ -5,7 +5,7 @@ interface PropertyRetrieverDelegate {
     property: string,
     receiver?: unknown,
     circularDependenciesDetector?: CircularDependenciesDetector
-  ) => unknown | undefined;
+  ) => unknown;
 }
 
 export default PropertyRetrieverDelegate;

package/src/graph/ProviderBinder.ts

@@ -1,10 +1,9 @@
-/* eslint-disable no-param-reassign */
 import providedPropertiesStore from '../ProvidedPropertiesStore';
 import { Graph } from './Graph';
 
 export function bindProviders(graph: Graph & Record<string, any>) {
   providedPropertiesStore.getMangledProperties(graph)
-    .filter((method) => graph[method])
+    .filter(method => graph[method])
     .forEach((method) => {
       graph[method] = graph[method].bind(graph);
     });

package/src/graph/registry/GraphRegistry.ts

@@ -25,7 +25,7 @@ export class GraphRegistry {
   getSubgraphs(graph: Graph): Graph[] {
     const Graph = this.instanceToConstructor.get(graph)!;
     const subgraphs = this.graphToSubgraphs.get(Graph) ?? new Set();
-    return Array.from(subgraphs).map((G) => this.resolve(G));
+    return Array.from(subgraphs).map(G => this.resolve(G));
   }
 
   getGraphInstance(name: string): Graph {
@@ -39,9 +39,9 @@ export class GraphRegistry {
     injectionToken?: string,
   ): T {
     if ((this.isSingleton(Graph) || this.isBoundToReactLifecycle(Graph)) && this.has(Graph, injectionToken)) {
-      return this.isComponentScopedLifecycleBound(Graph) ?
-        this.getByInjectionToken(Graph, injectionToken) :
-        this.getFirst(Graph);
+      return this.isComponentScopedLifecycleBound(Graph)
+        ? this.getByInjectionToken(Graph, injectionToken)
+        : this.getFirst(Graph);
     }
     if (this.isBoundToReactLifecycle(Graph) && source !== 'lifecycleOwner') {
       throw new ObtainLifecycleBoundGraphException(Graph);
@@ -58,14 +58,14 @@ export class GraphRegistry {
     if (this.isComponentScopedLifecycleBound(Graph)) {
       return Array
         .from(instances)
-        .some((graph) => this.instanceToInjectionToken.get(graph) === injectionToken);
+        .some(graph => this.instanceToInjectionToken.get(graph) === injectionToken);
     }
 
     return (this.constructorToInstance.get(Graph)?.size ?? 0) > 0;
   }
 
   private getFirst<T extends Graph>(Graph: Constructable<T>): T {
-    return this.constructorToInstance.get(Graph)!.values().next().value;
+    return this.constructorToInstance.get(Graph)!.values().next().value as T;
   }
 
   private getByInjectionToken<T extends Graph>(Graph: Constructable<T>, injectionToken?: string): T {
@@ -151,7 +151,7 @@ export class GraphRegistry {
   }
 }
 
-// @ts-ignore
+// @ts-expect-error - workaround an issue in jest tests where the registry was created multiple times
 global.graphRegistry = global.graphRegistry || new GraphRegistry();
-// @ts-ignore
+// @ts-expect-error - see above
 export default global.graphRegistry as GraphRegistry;

package/src/graph/registry/ObtainLifecycleBoundGraphException.ts

@@ -10,6 +10,6 @@ export class ObtainLifecycleBoundGraphException extends Error {
   private static createMessage(graph: Constructable<Graph>): string {
     const graphName = isDev() ? ` ${graph.name}` : '';
     return `Tried to obtain a @LifecycleBound graph${graphName}, but it was not created yet. `
-    + '@LifecycleBound graphs can only be obtained after they were created by a React component or hook.';
+      + '@LifecycleBound graphs can only be obtained after they were created by a React component or hook.';
   }
 }

package/src/index.ts

@@ -1,16 +1,59 @@
+import { graph } from './decorators/Graph';
+import { inject } from './decorators/inject/Inject';
+import { injectable } from './decorators/inject/Injectable';
+import { lateInject } from './decorators/inject/LateInject';
+import { lifecycleBound } from './decorators/LifecycleBound';
+import { provides } from './decorators/provides/Provides';
+import { singleton } from './decorators/Singleton';
 import _Obsidian from './Obsidian';
 
 export * from './types';
 
-export { Graph } from './decorators/Graph';
-export { Singleton } from './decorators/Singleton';
+export { graph } from './decorators/Graph';
+export { singleton } from './decorators/Singleton';
+export { provides } from './decorators/provides/Provides';
+export { injectable } from './decorators/inject/Injectable';
+export { inject } from './decorators/inject/Inject';
+export { lateInject } from './decorators/inject/LateInject';
+export { lifecycleBound } from './decorators/LifecycleBound';
+
+/**
+ * @deprecated Uppercase decorators are deprecated in favor of lowercase decorators to align with common naming conventions. Please use inject instead.
+ */
+export const Graph = graph;
+
+/**
+ * @deprecated Uppercase decorators are deprecated in favor of lowercase decorators to align with common naming convention. Please use `singleton` instead.
+ */
+export const Singleton = singleton;
+
+/**
+ * @deprecated Uppercase decorators are deprecated in favor of lowercase decorators to align with common naming convention. Please use `provides` instead.
+ */
+export const Provides = provides;
+
+/**
+ * @deprecated Uppercase decorators are deprecated in favor of lowercase decorators to align with common naming convention. Please use `injectable` instead.
+ */
+export const Injectable = injectable;
+
+/**
+ * @deprecated Uppercase decorators are deprecated in favor of lowercase decorators to align with common naming convention. Please use `inject` instead.
+ */
+export const Inject = inject;
+
+/**
+ * @deprecated Uppercase decorators are deprecated in favor of lowercase decorators to align with common naming convention. Please use `lateInject` instead.
+ */
+export const LateInject = lateInject;
+
+/**
+ * @deprecated Uppercase decorators are deprecated in favor of lowercase decorators to align with common naming convention. Please use `lifecycleBound` instead.
+ */
+export const LifecycleBound = lifecycleBound;
+
 export { ObjectGraph } from './graph/ObjectGraph';
 export { Graph as IGraph } from './graph/Graph';
-export { Provides } from './decorators/provides/Provides';
-export { Injectable } from './decorators/inject/Injectable';
-export { Inject } from './decorators/inject/Inject';
-export { LateInject } from './decorators/inject/LateInject';
-export { LifecycleBound } from './decorators/LifecycleBound';
 export { GraphMiddleware } from './graph/registry/GraphMiddleware';
 export { GraphResolveChain as ResolveChain } from './graph/registry/GraphResolveChain';
 

package/src/injectors/class/ClassInjector.ts

@@ -35,10 +35,10 @@ export default class ClassInjector {
         graph.onBind(target);
         const createdObject = Reflect.construct(target, argsToInject, newTarget);
         this.injectProperties(target, createdObject, graph);
-        const originalComponentWillUnmount = createdObject.componentWillUnmount;
+        const originalComponentWillUnmount: () => void | undefined = createdObject.componentWillUnmount;
         createdObject.componentWillUnmount = () => {
           originalComponentWillUnmount?.();
-          referenceCounter.release(graph, (g) => graphRegistry.clear(g));
+          referenceCounter.release(graph, g => graphRegistry.clear(g));
         };
         return createdObject;
       }

package/src/injectors/components/ComponentInjector.tsx

@@ -32,7 +32,7 @@ export default class ComponentInjector {
       const proxiedProps = new PropsInjector(graph).inject(passedProps);
 
       return (
-        <GraphContext.Provider value={{injectionToken}}>
+        <GraphContext.Provider value={{ injectionToken }}>
           {Target(proxiedProps as unknown as PropsWithChildren<P>)}
         </GraphContext.Provider>
       );

package/src/injectors/components/InjectComponent.ts

@@ -1,3 +1,4 @@
+import React from 'react';
 import { ObjectGraph } from '../../graph/ObjectGraph';
 import { Constructable } from '../../types';
 import ComponentInjector from './ComponentInjector';
@@ -18,9 +19,9 @@ export const injectComponent = <OwnProps = Discriminator, InjectedProps = Discri
   assertGraph(Graph, Target);
 
   return componentInjector.inject(Target, Graph) as React.FunctionComponent<
-  InjectedProps extends Discriminator ?
-    OwnProps extends Discriminator ? Partial<OwnProps> : OwnProps :
-    OwnProps extends InjectedProps ? Partial<OwnProps> : OwnProps & Partial<InjectedProps>
+    InjectedProps extends Discriminator ?
+      OwnProps extends Discriminator ? Partial<OwnProps> : OwnProps :
+      OwnProps extends InjectedProps ? Partial<OwnProps> : OwnProps & Partial<InjectedProps>
   >;
 };
 function assertGraph(Graph: Constructable<ObjectGraph<unknown>>, Target: any) {

package/src/injectors/components/PropsInjector.ts

@@ -4,7 +4,6 @@ export default class PropsInjector<Props> {
   constructor(private graph: ObjectGraph) {}
 
   inject(passedProps: Props): Partial<Props> {
-    // eslint-disable-next-line prefer-object-spread
     return new Proxy(Object.assign({}, passedProps), {
       get: (target: object, p: string, receiver: any): any => {
         return p in target ? Reflect.get(target, p, receiver) : this.graph.retrieve(p, receiver);

package/src/injectors/components/useGraph.ts

@@ -10,7 +10,6 @@ export default <P>(
   props?: Partial<P>,
   injectionToken?: string,
 ) => {
-
   const [graph] = useState(() => {
     const resolvedGraph = graphRegistry.resolve(Graph, 'lifecycleOwner', props, injectionToken);
     resolvedGraph.onBind(target);
@@ -18,7 +17,7 @@ export default <P>(
   });
   useEffect(() => {
     referenceCounter.retain(graph);
-    return () => referenceCounter.release(graph, (g) => graphRegistry.clear(g));
+    return () => referenceCounter.release(graph, g => graphRegistry.clear(g));
   }, [graph]);
   return graph;
 };

package/src/injectors/hooks/InjectHook.ts

@@ -1,4 +1,3 @@
-/* eslint-disable max-len */
 import { ObjectGraph } from '../../graph/ObjectGraph';
 import { Constructable } from '../../types';
 import HookInjector from './HookInjector';

package/src/observable/Observable.ts

@@ -14,7 +14,7 @@ export class Observable<T> implements IObservable<T> {
 
   public set value(value: T) {
     this.currentValue = value;
-    this.subscribers.forEach((subscriber) => subscriber(value));
+    this.subscribers.forEach(subscriber => subscriber(value));
   }
 
   async first(): Promise<T> {
@@ -35,7 +35,7 @@ export class Observable<T> implements IObservable<T> {
     return () => this.subscribers.delete(onNext);
   }
 
-  public unsubscribe(onNext:OnNext<T>) {
+  public unsubscribe(onNext: OnNext<T>) {
     if (!this.subscribers.has(onNext)) {
       throw new Error(`Can't unsubscribe, subscriber doesn't exist`);
     }

package/src/observable/cold/ColdMediatorObservable.ts

@@ -1,7 +1,6 @@
 import { Observable } from '../Observable';
 import { MediatorObservable } from '../mediator/MediatorObservable';
 import { OnNext } from '../types';
-
 export class ColdMediatorObservable<T extends object> extends MediatorObservable<T> {
   constructor(obj: T, private readonly handler = new PropertyAccessTrackingProxy<T>()) {
     super(new Proxy(obj, handler));

package/src/observable/cold/useColdObservers.ts

@@ -10,7 +10,7 @@ export function useColdObservables<T extends Record<string, any>>(observables: T
   const [values, setValues] = useState(() => mediator.value as ObservedValues<T>);
 
   useEffect(() => {
-    Object.keys(observables as {}).forEach((key) => {
+    Object.keys(observables).forEach((key) => {
       mediator.addSource(observables[key], (value) => {
         mediator.setValue(key, value);
       });

package/src/observable/mediator/MediatorObservable.ts

@@ -67,7 +67,7 @@ export class MediatorObservable<T> extends Observable<T> {
             values[index] = next;
           } else {
             values[index] = next;
-            this.value = mapNext(values, this.value) as T;
+            this.value = mapNext(values, this.value);
           }
         });
       });

package/src/observable/useObserver.ts

@@ -1,4 +1,3 @@
-/* eslint-disable no-param-reassign */
 import {
   useCallback,
   useEffect,
@@ -26,6 +25,6 @@ export function useObserver<T>(observableOrGenerator: ObservableOrGenerator<T>):
   return [value, onNext];
 }
 
-function getOrGenerateObservable(observableOrGenerator: ObservableOrGenerator<any>) {
+function getOrGenerateObservable<T>(observableOrGenerator: ObservableOrGenerator<T>): Observable<T> {
   return observableOrGenerator instanceof Observable ? observableOrGenerator : observableOrGenerator();
 }

package/src/observable/useObservers.ts

@@ -2,15 +2,16 @@ import { useEffect, useState } from 'react';
 import { MediatorObservable } from './mediator/MediatorObservable';
 import { ObservedValues, Unsubscribe } from './types';
 import { mapObservablesToValues } from './mapObservablesToValues';
+import type { Observable } from './Observable';
 
-export function useObservers<T extends Record<string, any>>(observables: T): ObservedValues<T> {
+export function useObservers<T extends Record<string, Observable<any>>>(observables: T): ObservedValues<T> {
   const [values, setValues] = useState(() => mapObservablesToValues(observables));
 
   useEffect(() => {
     const mediator = new MediatorObservable();
     const unsubscribers: Unsubscribe[] = [];
 
-    Object.keys(observables as {}).forEach((key) => {
+    Object.keys(observables).forEach((key) => {
       const onNext = (value: any) => setValues({ ...values, [key]: value });
       mediator.addSource(observables[key], onNext);
 
@@ -19,7 +20,7 @@ export function useObservers<T extends Record<string, any>>(observables: T): Obs
       });
     });
 
-    return () => unsubscribers.forEach((unsubscribe) => unsubscribe());
+    return () => unsubscribers.forEach(unsubscribe => unsubscribe());
   }, []);
 
   return values;

package/src/utils/isDev.ts

@@ -3,11 +3,11 @@ export function isDev(): boolean {
 }
 
 function isNodeDev(): boolean {
-  // eslint-disable-next-line @typescript-eslint/dot-notation
   return ['test', 'development'].includes(process.env['NODE_ENV'] ?? '');
 }
 
 function isReactNativeDev(): boolean {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
   // @ts-ignore
   return __DEV__ as boolean ?? false;
 }

package/testkit/index.ts

@@ -7,7 +7,6 @@ class TestKit {
    * @deprecated testKit.mockGraphs is deprecated, use mockGraphs instead
    */
   public mockGraphs(graphNameToGraph: Record<string, Constructable<ObjectGraph> | ((props: any) => ObjectGraph)>) {
-    // eslint-disable-next-line no-console
     console.warn('testKit.mockGraphs is deprecated, use mockGraphs instead');
     return mockGraphs(graphNameToGraph);
   }