react-saga-redux 1.0.1

package/src/types.ts

@@ -0,0 +1,180 @@
+import type {
+  ClassAttributes,
+  ComponentClass,
+  ComponentType,
+  FunctionComponent,
+  JSX,
+} from 'react'
+
+import type { Action, UnknownAction, Dispatch } from 'redux'
+
+import type { NonReactStatics } from './utils/hoistStatics'
+
+import type { ConnectProps } from './components/connect'
+
+import type { UseSelectorOptions } from './hooks/useSelector'
+
+export type FixTypeLater = any
+
+export type EqualityFn<T> = (a: T, b: T) => boolean
+
+export type ExtendedEqualityFn<T, P> = (a: T, b: T, c: P, d: P) => boolean
+
+export type AnyIfEmpty<T extends object> = keyof T extends never ? any : T
+
+export type DistributiveOmit<T, K extends keyof T> = T extends unknown
+  ? Omit<T, K>
+  : never
+
+export interface DispatchProp<A extends Action<string> = UnknownAction> {
+  dispatch: Dispatch<A>
+}
+
+/**
+ * A property P will be present if:
+ * - it is present in DecorationTargetProps
+ *
+ * Its value will be dependent on the following conditions
+ * - if property P is present in InjectedProps and its definition extends the definition
+ *   in DecorationTargetProps, then its definition will be that of DecorationTargetProps[P]
+ * - if property P is not present in InjectedProps then its definition will be that of
+ *   DecorationTargetProps[P]
+ * - if property P is present in InjectedProps but does not extend the
+ *   DecorationTargetProps[P] definition, its definition will be that of InjectedProps[P]
+ */
+export type Matching<InjectedProps, DecorationTargetProps> = {
+  [P in keyof DecorationTargetProps]: P extends keyof InjectedProps
+    ? InjectedProps[P] extends DecorationTargetProps[P]
+      ? DecorationTargetProps[P]
+      : InjectedProps[P]
+    : DecorationTargetProps[P]
+}
+
+/**
+ * a property P will be present if :
+ * - it is present in both DecorationTargetProps and InjectedProps
+ * - InjectedProps[P] can satisfy DecorationTargetProps[P]
+ * ie: decorated component can accept more types than decorator is injecting
+ *
+ * For decoration, inject props or ownProps are all optionally
+ * required by the decorated (right hand side) component.
+ * But any property required by the decorated component must be satisfied by the injected property.
+ */
+export type Shared<InjectedProps, DecorationTargetProps> = {
+  [P in Extract<
+    keyof InjectedProps,
+    keyof DecorationTargetProps
+  >]?: InjectedProps[P] extends DecorationTargetProps[P]
+    ? DecorationTargetProps[P]
+    : never
+}
+
+// Infers prop type from component C
+export type GetProps<C> =
+  C extends ComponentType<infer P>
+    ? C extends ComponentClass<P>
+      ? ClassAttributes<InstanceType<C>> & P
+      : P
+    : never
+
+// Applies LibraryManagedAttributes (proper handling of defaultProps
+// and propTypes).
+export type GetLibraryManagedProps<C> = JSX.LibraryManagedAttributes<
+  C,
+  GetProps<C>
+>
+
+// Applies LibraryManagedAttributes (proper handling of defaultProps
+// and propTypes), as well as defines WrappedComponent.
+export type ConnectedComponent<
+  C extends ComponentType<any>,
+  P,
+> = FunctionComponent<P> &
+  NonReactStatics<C> & {
+    WrappedComponent: C
+  }
+
+export type ConnectPropsMaybeWithoutContext<TActualOwnProps> =
+  TActualOwnProps extends { context: any }
+    ? Omit<ConnectProps, 'context'>
+    : ConnectProps
+
+type Identity<T> = T
+export type Mapped<T> = Identity<{ [k in keyof T]: T[k] }>
+
+// Injects props and removes them from the prop requirements.
+// Will not pass through the injected props if they are passed in during
+// render. Also adds new prop requirements from TNeedsProps.
+// Uses distributive omit to preserve discriminated unions part of original prop type.
+// Note> Most of the time TNeedsProps is empty, because the overloads in `Connect`
+// just pass in `{}`.  The real props we need come from the component.
+export type InferableComponentEnhancerWithProps<TInjectedProps, TNeedsProps> = <
+  C extends ComponentType<Matching<TInjectedProps, GetProps<C>>>,
+>(
+  component: C,
+) => ConnectedComponent<
+  C,
+  Mapped<
+    DistributiveOmit<
+      GetLibraryManagedProps<C>,
+      keyof Shared<TInjectedProps, GetLibraryManagedProps<C>>
+    > &
+      TNeedsProps &
+      ConnectPropsMaybeWithoutContext<TNeedsProps & GetProps<C>>
+  >
+>
+
+// Injects props and removes them from the prop requirements.
+// Will not pass through the injected props if they are passed in during
+// render.
+export type InferableComponentEnhancer<TInjectedProps> =
+  InferableComponentEnhancerWithProps<TInjectedProps, {}>
+
+export type InferThunkActionCreatorType<
+  TActionCreator extends (...args: any[]) => any,
+> = TActionCreator extends (
+  ...args: infer TParams
+) => (...args: any[]) => infer TReturn
+  ? (...args: TParams) => TReturn
+  : TActionCreator
+
+export type HandleThunkActionCreator<TActionCreator> = TActionCreator extends (
+  ...args: any[]
+) => any
+  ? InferThunkActionCreatorType<TActionCreator>
+  : TActionCreator
+
+// redux-thunk middleware returns thunk's return value from dispatch call
+// https://github.com/reduxjs/redux-thunk#composition
+export type ResolveThunks<TDispatchProps> = TDispatchProps extends {
+  [key: string]: any
+}
+  ? {
+      [C in keyof TDispatchProps]: HandleThunkActionCreator<TDispatchProps[C]>
+    }
+  : TDispatchProps
+
+/**
+ * This interface allows you to easily create a hook that is properly typed for your
+ * store's root state.
+ *
+ * @example
+ *
+ * interface RootState {
+ *   property: string;
+ * }
+ *
+ * const useTypedSelector: TypedUseSelectorHook<RootState> = useSelector;
+ */
+export interface TypedUseSelectorHook<TState> {
+  <TSelected>(
+    selector: (state: TState) => TSelected,
+    equalityFn?: EqualityFn<NoInfer<TSelected>>,
+  ): TSelected
+  <Selected = unknown>(
+    selector: (state: TState) => Selected,
+    options?: UseSelectorOptions<Selected>,
+  ): Selected
+}
+
+export type NoInfer<T> = [T][T extends any ? 0 : never]

package/src/utils/Subscription.ts

@@ -0,0 +1,183 @@
+import { defaultNoopBatch as batch } from './batch'
+
+// encapsulates the subscription logic for connecting a component to the redux store, as
+// well as nesting subscriptions of descendant components, so that we can ensure the
+// ancestor components re-render before descendants
+
+type VoidFunc = () => void
+
+type Listener = {
+  callback: VoidFunc
+  next: Listener | null
+  prev: Listener | null
+}
+
+function createListenerCollection() {
+  let first: Listener | null = null
+  let last: Listener | null = null
+
+  return {
+    clear() {
+      first = null
+      last = null
+    },
+
+    notify() {
+      batch(() => {
+        let listener = first
+        while (listener) {
+          listener.callback()
+          listener = listener.next
+        }
+      })
+    },
+
+    get() {
+      const listeners: Listener[] = []
+      let listener = first
+      while (listener) {
+        listeners.push(listener)
+        listener = listener.next
+      }
+      return listeners
+    },
+
+    subscribe(callback: () => void) {
+      let isSubscribed = true
+
+      const listener: Listener = (last = {
+        callback,
+        next: null,
+        prev: last,
+      })
+
+      if (listener.prev) {
+        listener.prev.next = listener
+      } else {
+        first = listener
+      }
+
+      return function unsubscribe() {
+        if (!isSubscribed || first === null) return
+        isSubscribed = false
+
+        if (listener.next) {
+          listener.next.prev = listener.prev
+        } else {
+          last = listener.prev
+        }
+        if (listener.prev) {
+          listener.prev.next = listener.next
+        } else {
+          first = listener.next
+        }
+      }
+    },
+  }
+}
+
+type ListenerCollection = ReturnType<typeof createListenerCollection>
+
+export interface Subscription {
+  addNestedSub: (listener: VoidFunc) => VoidFunc
+  notifyNestedSubs: VoidFunc
+  handleChangeWrapper: VoidFunc
+  isSubscribed: () => boolean
+  onStateChange?: VoidFunc | null
+  trySubscribe: VoidFunc
+  tryUnsubscribe: VoidFunc
+  getListeners: () => ListenerCollection
+}
+
+const nullListeners = {
+  notify() {},
+  get: () => [],
+} as unknown as ListenerCollection
+
+export function createSubscription(store: any, parentSub?: Subscription) {
+  let unsubscribe: VoidFunc | undefined
+  let listeners: ListenerCollection = nullListeners
+
+  // Reasons to keep the subscription active
+  let subscriptionsAmount = 0
+
+  // Is this specific subscription subscribed (or only nested ones?)
+  let selfSubscribed = false
+
+  function addNestedSub(listener: () => void) {
+    trySubscribe()
+
+    const cleanupListener = listeners.subscribe(listener)
+
+    // cleanup nested sub
+    let removed = false
+    return () => {
+      if (!removed) {
+        removed = true
+        cleanupListener()
+        tryUnsubscribe()
+      }
+    }
+  }
+
+  function notifyNestedSubs() {
+    listeners.notify()
+  }
+
+  function handleChangeWrapper() {
+    if (subscription.onStateChange) {
+      subscription.onStateChange()
+    }
+  }
+
+  function isSubscribed() {
+    return selfSubscribed
+  }
+
+  function trySubscribe() {
+    subscriptionsAmount++
+    if (!unsubscribe) {
+      unsubscribe = parentSub
+        ? parentSub.addNestedSub(handleChangeWrapper)
+        : store.subscribe(handleChangeWrapper)
+
+      listeners = createListenerCollection()
+    }
+  }
+
+  function tryUnsubscribe() {
+    subscriptionsAmount--
+    if (unsubscribe && subscriptionsAmount === 0) {
+      unsubscribe()
+      unsubscribe = undefined
+      listeners.clear()
+      listeners = nullListeners
+    }
+  }
+
+  function trySubscribeSelf() {
+    if (!selfSubscribed) {
+      selfSubscribed = true
+      trySubscribe()
+    }
+  }
+
+  function tryUnsubscribeSelf() {
+    if (selfSubscribed) {
+      selfSubscribed = false
+      tryUnsubscribe()
+    }
+  }
+
+  const subscription: Subscription = {
+    addNestedSub,
+    notifyNestedSubs,
+    handleChangeWrapper,
+    isSubscribed,
+    trySubscribe: trySubscribeSelf,
+    tryUnsubscribe: tryUnsubscribeSelf,
+    getListeners: () => listeners,
+  }
+
+  return subscription
+}

package/src/utils/batch.ts

@@ -0,0 +1,4 @@
+// Default to a dummy "batch" implementation that just runs the callback
+export function defaultNoopBatch(callback: () => void) {
+  callback()
+}

package/src/utils/bindActionCreators.ts

@@ -0,0 +1,16 @@
+import type { ActionCreatorsMapObject, Dispatch } from 'redux'
+
+export default function bindActionCreators(
+  actionCreators: ActionCreatorsMapObject,
+  dispatch: Dispatch,
+): ActionCreatorsMapObject {
+  const boundActionCreators: ActionCreatorsMapObject = {}
+
+  for (const key in actionCreators) {
+    const actionCreator = actionCreators[key]
+    if (typeof actionCreator === 'function') {
+      boundActionCreators[key] = (...args) => dispatch(actionCreator(...args))
+    }
+  }
+  return boundActionCreators
+}

package/src/utils/constants.ts

@@ -0,0 +1,23 @@
+/**
+ * Represents default log level values
+ */
+export const DEFAULT_LEVELS = {
+  trace: 10,
+  debug: 20,
+  info: 30,
+  warn: 40,
+  error: 50,
+  fatal: 60,
+} as const;
+
+/**
+ * Represents sort order direction: `ascending` or `descending`
+ */
+export const SORTING_ORDER = {
+  ASC: 'ASC',
+  DESC: 'DESC',
+} as const;
+
+// Type exports (optional but useful)
+export type DefaultLevels = typeof DEFAULT_LEVELS;
+export type SortingOrder = typeof SORTING_ORDER;

package/src/utils/hoistStatics.ts

@@ -0,0 +1,139 @@
+// Copied directly from:
+// https://github.com/mridgway/hoist-non-react-statics/blob/main/src/index.js
+// https://unpkg.com/browse/@types/hoist-non-react-statics@3.3.6/index.d.ts
+
+/**
+ * Copyright 2015, Yahoo! Inc.
+ * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+ */
+import type { ForwardRefExoticComponent, MemoExoticComponent } from 'react'
+import { ForwardRef, Memo, isMemo } from '../utils/react-is'
+
+const REACT_STATICS = {
+  childContextTypes: true,
+  contextType: true,
+  contextTypes: true,
+  defaultProps: true,
+  displayName: true,
+  getDefaultProps: true,
+  getDerivedStateFromError: true,
+  getDerivedStateFromProps: true,
+  mixins: true,
+  propTypes: true,
+  type: true,
+} as const
+
+const KNOWN_STATICS = {
+  name: true,
+  length: true,
+  prototype: true,
+  caller: true,
+  callee: true,
+  arguments: true,
+  arity: true,
+} as const
+
+const FORWARD_REF_STATICS = {
+  $$typeof: true,
+  render: true,
+  defaultProps: true,
+  displayName: true,
+  propTypes: true,
+} as const
+
+const MEMO_STATICS = {
+  $$typeof: true,
+  compare: true,
+  defaultProps: true,
+  displayName: true,
+  propTypes: true,
+  type: true,
+} as const
+
+const TYPE_STATICS = {
+  [ForwardRef]: FORWARD_REF_STATICS,
+  [Memo]: MEMO_STATICS,
+} as const
+
+function getStatics(component: any) {
+  // React v16.11 and below
+  if (isMemo(component)) {
+    return MEMO_STATICS
+  }
+
+  // React v16.12 and above
+  return TYPE_STATICS[component['$$typeof']] || REACT_STATICS
+}
+
+export type NonReactStatics<
+  Source,
+  C extends {
+    [key: string]: true
+  } = {},
+> = {
+  [key in Exclude<
+    keyof Source,
+    Source extends MemoExoticComponent<any>
+      ? keyof typeof MEMO_STATICS | keyof C
+      : Source extends ForwardRefExoticComponent<any>
+        ? keyof typeof FORWARD_REF_STATICS | keyof C
+        : keyof typeof REACT_STATICS | keyof typeof KNOWN_STATICS | keyof C
+  >]: Source[key]
+}
+
+const defineProperty = Object.defineProperty
+const getOwnPropertyNames = Object.getOwnPropertyNames
+const getOwnPropertySymbols = Object.getOwnPropertySymbols
+const getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor
+const getPrototypeOf = Object.getPrototypeOf
+const objectPrototype = Object.prototype
+
+export default function hoistNonReactStatics<
+  Target,
+  Source,
+  CustomStatic extends {
+    [key: string]: true
+  } = {},
+>(
+  targetComponent: Target,
+  sourceComponent: Source,
+): Target & NonReactStatics<Source, CustomStatic> {
+  if (typeof sourceComponent !== 'string') {
+    // don't hoist over string (html) components
+
+    if (objectPrototype) {
+      const inheritedComponent = getPrototypeOf(sourceComponent)
+      if (inheritedComponent && inheritedComponent !== objectPrototype) {
+        hoistNonReactStatics(targetComponent, inheritedComponent)
+      }
+    }
+
+    let keys: (string | symbol)[] = getOwnPropertyNames(sourceComponent)
+
+    if (getOwnPropertySymbols) {
+      keys = keys.concat(getOwnPropertySymbols(sourceComponent))
+    }
+
+    const targetStatics = getStatics(targetComponent)
+    const sourceStatics = getStatics(sourceComponent)
+
+    for (let i = 0; i < keys.length; ++i) {
+      const key = keys[i]
+      if (
+        !KNOWN_STATICS[key as keyof typeof KNOWN_STATICS] &&
+        !(sourceStatics && sourceStatics[key as keyof typeof sourceStatics]) &&
+        !(targetStatics && targetStatics[key as keyof typeof targetStatics])
+      ) {
+        const descriptor = getOwnPropertyDescriptor(sourceComponent, key)
+        try {
+          // Avoid failures from read-only properties
+          defineProperty(targetComponent, key, descriptor!)
+        } catch (e) {
+          // ignore
+        }
+      }
+    }
+  }
+
+  return targetComponent as any
+}

package/src/utils/isPlainObject.ts

@@ -0,0 +1,17 @@
+/**
+ * @param {any} obj The object to inspect.
+ * @returns {boolean} True if the argument appears to be a plain object.
+ */
+export default function isPlainObject(obj: unknown) {
+  if (typeof obj !== 'object' || obj === null) return false
+
+  const proto = Object.getPrototypeOf(obj)
+  if (proto === null) return true
+
+  let baseProto = proto
+  while (Object.getPrototypeOf(baseProto) !== null) {
+    baseProto = Object.getPrototypeOf(baseProto)
+  }
+
+  return proto === baseProto
+}

package/src/utils/react-is.ts

@@ -0,0 +1,97 @@
+import type { ElementType, MemoExoticComponent, ReactElement } from 'react'
+import { React } from './react'
+
+// Directly ported from:
+// https://unpkg.com/browse/react-is@19.0.0/cjs/react-is.production.js
+// It's very possible this could change in the future, but given that
+// we only use these in `connect`, this is a low priority.
+
+export const IS_REACT_19 = /* @__PURE__ */ React.version.startsWith('19')
+
+const REACT_ELEMENT_TYPE = /* @__PURE__ */ Symbol.for(
+  IS_REACT_19 ? 'react.transitional.element' : 'react.element',
+)
+const REACT_PORTAL_TYPE = /* @__PURE__ */ Symbol.for('react.portal')
+const REACT_FRAGMENT_TYPE = /* @__PURE__ */ Symbol.for('react.fragment')
+const REACT_STRICT_MODE_TYPE = /* @__PURE__ */ Symbol.for('react.strict_mode')
+const REACT_PROFILER_TYPE = /* @__PURE__ */ Symbol.for('react.profiler')
+const REACT_CONSUMER_TYPE = /* @__PURE__ */ Symbol.for('react.consumer')
+const REACT_CONTEXT_TYPE = /* @__PURE__ */ Symbol.for('react.context')
+const REACT_FORWARD_REF_TYPE = /* @__PURE__ */ Symbol.for('react.forward_ref')
+const REACT_SUSPENSE_TYPE = /* @__PURE__ */ Symbol.for('react.suspense')
+const REACT_SUSPENSE_LIST_TYPE = /* @__PURE__ */ Symbol.for(
+  'react.suspense_list',
+)
+const REACT_MEMO_TYPE = /* @__PURE__ */ Symbol.for('react.memo')
+const REACT_LAZY_TYPE = /* @__PURE__ */ Symbol.for('react.lazy')
+const REACT_OFFSCREEN_TYPE = /* @__PURE__ */ Symbol.for('react.offscreen')
+const REACT_CLIENT_REFERENCE = /* @__PURE__ */ Symbol.for(
+  'react.client.reference',
+)
+
+export const ForwardRef = REACT_FORWARD_REF_TYPE
+export const Memo = REACT_MEMO_TYPE
+
+export function isValidElementType(type: any): type is ElementType {
+  return typeof type === 'string' ||
+    typeof type === 'function' ||
+    type === REACT_FRAGMENT_TYPE ||
+    type === REACT_PROFILER_TYPE ||
+    type === REACT_STRICT_MODE_TYPE ||
+    type === REACT_SUSPENSE_TYPE ||
+    type === REACT_SUSPENSE_LIST_TYPE ||
+    type === REACT_OFFSCREEN_TYPE ||
+    (typeof type === 'object' &&
+      type !== null &&
+      (type.$$typeof === REACT_LAZY_TYPE ||
+        type.$$typeof === REACT_MEMO_TYPE ||
+        type.$$typeof === REACT_CONTEXT_TYPE ||
+        type.$$typeof === REACT_CONSUMER_TYPE ||
+        type.$$typeof === REACT_FORWARD_REF_TYPE ||
+        type.$$typeof === REACT_CLIENT_REFERENCE ||
+        type.getModuleId !== undefined))
+    ? !0
+    : !1
+}
+
+function typeOf(object: any): symbol | undefined {
+  if (typeof object === 'object' && object !== null) {
+    const { $$typeof } = object
+
+    switch ($$typeof) {
+      case REACT_ELEMENT_TYPE:
+        switch (((object = object.type), object)) {
+          case REACT_FRAGMENT_TYPE:
+          case REACT_PROFILER_TYPE:
+          case REACT_STRICT_MODE_TYPE:
+          case REACT_SUSPENSE_TYPE:
+          case REACT_SUSPENSE_LIST_TYPE:
+            return object
+          default:
+            switch (((object = object && object.$$typeof), object)) {
+              case REACT_CONTEXT_TYPE:
+              case REACT_FORWARD_REF_TYPE:
+              case REACT_LAZY_TYPE:
+              case REACT_MEMO_TYPE:
+                return object
+              case REACT_CONSUMER_TYPE:
+                return object
+              default:
+                return $$typeof
+            }
+        }
+      case REACT_PORTAL_TYPE:
+        return $$typeof
+    }
+  }
+}
+
+export function isContextConsumer(object: any): object is ReactElement {
+  return IS_REACT_19
+    ? typeOf(object) === REACT_CONSUMER_TYPE
+    : typeOf(object) === REACT_CONTEXT_TYPE
+}
+
+export function isMemo(object: any): object is MemoExoticComponent<any> {
+  return typeOf(object) === REACT_MEMO_TYPE
+}

package/src/utils/react.ts

@@ -0,0 +1,3 @@
+import * as React from 'react'
+
+export { React }

package/src/utils/shallowEqual.ts

@@ -0,0 +1,36 @@
+function is(x: unknown, y: unknown) {
+  if (x === y) {
+    return x !== 0 || y !== 0 || 1 / x === 1 / y
+  } else {
+    return x !== x && y !== y
+  }
+}
+
+export default function shallowEqual(objA: any, objB: any) {
+  if (is(objA, objB)) return true
+
+  if (
+    typeof objA !== 'object' ||
+    objA === null ||
+    typeof objB !== 'object' ||
+    objB === null
+  ) {
+    return false
+  }
+
+  const keysA = Object.keys(objA)
+  const keysB = Object.keys(objB)
+
+  if (keysA.length !== keysB.length) return false
+
+  for (let i = 0; i < keysA.length; i++) {
+    if (
+      !Object.prototype.hasOwnProperty.call(objB, keysA[i]) ||
+      !is(objA[keysA[i]], objB[keysA[i]])
+    ) {
+      return false
+    }
+  }
+
+  return true
+}