@tanstack/angular-query-experimental 5.15.5 → 5.16.1

package/src/util/assert-injector/assert-injector.ts

@@ -0,0 +1,79 @@
+/**
+ * The code in this file is adapted from NG Extension Platform at https://ngxtension.netlify.app.
+ *
+ * Original Author: Chau Tran
+ *
+ * NG Extension Platform is an open-source project licensed under the MIT license.
+ *
+ * For more information about the original code, see
+ * https://github.com/nartc/ngxtension-platform
+ */
+
+import {
+  Injector,
+  assertInInjectionContext,
+  inject,
+  runInInjectionContext,
+} from '@angular/core'
+
+/**
+ * `assertInjector` extends `assertInInjectionContext` with an optional `Injector`
+ * After assertion, `assertInjector` runs the `runner` function with the guaranteed `Injector`
+ * whether it is the default `Injector` within the current **Injection Context**
+ * or the custom `Injector` that was passed in.
+ *
+ * @template {() => any} Runner - Runner is a function that can return anything
+ * @param {Function} fn - the Function to pass in `assertInInjectionContext`
+ * @param {Injector | undefined | null} injector - the optional "custom" Injector
+ * @param {Runner} runner - the runner fn
+ * @returns {ReturnType<Runner>} result - returns the result of the Runner
+ *
+ * @example
+ * ```ts
+ * function injectValue(injector?: Injector) {
+ *  return assertInjector(injectValue, injector, () => 'value');
+ * }
+ *
+ * injectValue(); // string
+ * ```
+ */
+export function assertInjector<Runner extends () => any>(
+  fn: Function,
+  injector: Injector | undefined | null,
+  runner: Runner,
+): ReturnType<Runner>
+/**
+ * `assertInjector` extends `assertInInjectionContext` with an optional `Injector`
+ * After assertion, `assertInjector` returns a guaranteed `Injector` whether it is the default `Injector`
+ * within the current **Injection Context** or the custom `Injector` that was passed in.
+ *
+ * @param {Function} fn - the Function to pass in `assertInInjectionContext`
+ * @param {Injector | undefined | null} injector - the optional "custom" Injector
+ * @returns Injector
+ *
+ * @example
+ * ```ts
+ * function injectDestroy(injector?: Injector) {
+ *  injector = assertInjector(injectDestroy, injector);
+ *
+ *  return runInInjectionContext(injector, () => {
+ *    // code
+ *  })
+ * }
+ * ```
+ */
+export function assertInjector(
+  fn: Function,
+  injector: Injector | undefined | null,
+): Injector
+export function assertInjector(
+  fn: Function,
+  injector: Injector | undefined | null,
+  runner?: () => any,
+) {
+  !injector && assertInInjectionContext(fn)
+  const assertedInjector = injector ?? inject(Injector)
+
+  if (!runner) return assertedInjector
+  return runInInjectionContext(assertedInjector, runner)
+}

package/src/util/create-injection-token/create-injection-token.test.ts

@@ -0,0 +1,30 @@
+/**
+ * The code in this file is adapted from NG Extension Platform at https://ngxtension.netlify.app.
+ *
+ * Original Author: Chau Tran
+ *
+ * NG Extension Platform is an open-source project licensed under the MIT license.
+ *
+ * For more information about the original code, see
+ * https://github.com/nartc/ngxtension-platform
+ */
+
+import { TestBed } from '@angular/core/testing'
+import { createNoopInjectionToken } from './create-injection-token'
+
+describe(createNoopInjectionToken.name, () => {
+  describe('given an injection token', () => {
+    const [injectFn, provideFn] = createNoopInjectionToken<number, true>(
+      'noop',
+      { multi: true },
+    )
+    it('then work properly', () => {
+      TestBed.configureTestingModule({
+        providers: [provideFn(1), provideFn(() => 2)],
+      }).runInInjectionContext(() => {
+        const values = injectFn()
+        expect(values).toEqual([1, 2])
+      })
+    })
+  })
+})

package/src/util/create-injection-token/create-injection-token.ts

@@ -0,0 +1,184 @@
+/**
+ * The code in this file is adapted from NG Extension Platform at https://ngxtension.netlify.app.
+ *
+ * Original Author: Chau Tran
+ *
+ * NG Extension Platform is an open-source project licensed under the MIT license.
+ *
+ * For more information about the original code, see
+ * https://github.com/nartc/ngxtension-platform
+ */
+
+import {
+  type EnvironmentProviders,
+  type FactoryProvider,
+  type Host,
+  type InjectOptions,
+  InjectionToken,
+  type Injector,
+  type Optional,
+  type Provider,
+  type Self,
+  type SkipSelf,
+  type Type,
+  inject,
+  runInInjectionContext,
+} from '@angular/core'
+import { assertInjector } from '../assert-injector/assert-injector'
+
+type CreateInjectionTokenDep<TTokenType> =
+  | Type<TTokenType>
+  // NOTE: we don't have an AbstractType
+  | (abstract new (...args: Array<any>) => TTokenType)
+  | InjectionToken<TTokenType>
+
+type CreateInjectionTokenDeps<
+  TFactory extends (...args: Array<any>) => any,
+  TFactoryDeps extends Parameters<TFactory> = Parameters<TFactory>,
+> = {
+  [Index in keyof TFactoryDeps]:
+    | CreateInjectionTokenDep<TFactoryDeps[Index]>
+    | [
+        ...modifiers: Array<Optional | Self | SkipSelf | Host>,
+        token: CreateInjectionTokenDep<TFactoryDeps[Index]>,
+      ]
+} & { length: TFactoryDeps['length'] }
+
+type CreateInjectionTokenOptions<
+  TFactory extends (...args: Array<any>) => any,
+  TFactoryDeps extends Parameters<TFactory> = Parameters<TFactory>,
+> =
+  // this means TFunction has no parameters
+  (TFactoryDeps[0] extends undefined
+    ? { deps?: never }
+    : { deps: CreateInjectionTokenDeps<TFactory, TFactoryDeps> }) & {
+    isRoot?: boolean
+    multi?: boolean
+    token?: InjectionToken<ReturnType<TFactory>>
+    extraProviders?: Provider | EnvironmentProviders
+  }
+
+type CreateProvideFnOptions<
+  TFactory extends (...args: Array<any>) => any,
+  TFactoryDeps extends Parameters<TFactory> = Parameters<TFactory>,
+> = Pick<
+  CreateInjectionTokenOptions<TFactory, TFactoryDeps>,
+  'deps' | 'extraProviders' | 'multi'
+>
+
+type InjectFn<TFactoryReturn> = {
+  (): TFactoryReturn
+  (
+    injectOptions: InjectOptions & { optional?: false } & {
+      injector?: Injector
+    },
+  ): TFactoryReturn
+  (
+    injectOptions: InjectOptions & { injector?: Injector },
+  ): TFactoryReturn | null
+}
+
+type ProvideFn<
+  TNoop extends boolean,
+  TFactoryReturn,
+  TReturn = TFactoryReturn extends Array<infer Item> ? Item : TFactoryReturn,
+> = (TNoop extends true
+  ? (value: TReturn | (() => TReturn)) => Provider
+  : () => Provider) &
+  (TReturn extends Function
+    ? (value: TReturn | (() => TReturn), isFunctionValue: boolean) => Provider
+    : (value: TReturn | (() => TReturn)) => Provider)
+
+type CreateInjectionTokenReturn<
+  TFactoryReturn,
+  TNoop extends boolean = false,
+> = [
+  InjectFn<TFactoryReturn>,
+  ProvideFn<TNoop, TFactoryReturn>,
+  InjectionToken<TFactoryReturn>,
+  () => Provider,
+]
+
+function createInjectFn<TValue>(token: InjectionToken<TValue>) {
+  return function (
+    this: Function,
+    {
+      injector,
+      ...injectOptions
+    }: InjectOptions & { injector?: Injector } = {},
+  ) {
+    injector = assertInjector(this, injector)
+    return runInInjectionContext(injector, () =>
+      inject(token, injectOptions as InjectOptions),
+    )
+  }
+}
+
+function createProvideFn<
+  TValue,
+  TFactory extends (...args: Array<any>) => any = (
+    ...args: Array<any>
+  ) => TValue,
+  TFactoryDeps extends Parameters<TFactory> = Parameters<TFactory>,
+>(
+  token: InjectionToken<TValue>,
+  factory: (...args: Array<any>) => TValue,
+  opts: CreateProvideFnOptions<TFactory, TFactoryDeps> = {},
+) {
+  const { deps = [], multi = false, extraProviders = [] } = opts
+  return (value?: TValue | (() => TValue), isFunctionValue = false) => {
+    let provider: Provider
+    if (typeof value !== 'undefined') {
+      // eslint-disable-next-line no-shadow
+      const factory =
+        typeof value === 'function'
+          ? isFunctionValue
+            ? () => value
+            : value
+          : () => value
+
+      provider = {
+        provide: token,
+        useFactory: factory,
+        multi,
+      }
+    } else {
+      provider = {
+        provide: token,
+        useFactory: factory,
+        deps: deps as FactoryProvider['deps'],
+        multi,
+      }
+    }
+
+    return [extraProviders, provider]
+  }
+}
+
+export function createNoopInjectionToken<
+  TValue,
+  TMulti extends boolean = false,
+  TOptions = Pick<
+    CreateInjectionTokenOptions<() => void, []>,
+    'extraProviders'
+  > &
+    (TMulti extends true ? { multi: true } : Record<string, never>),
+>(description: string, options?: TOptions) {
+  type TReturn = TMulti extends true ? Array<TValue> : TValue
+
+  const token =
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    (options as CreateInjectionTokenOptions<() => void, []>)?.token ||
+    new InjectionToken<TReturn>(description)
+  return [
+    createInjectFn(token) as CreateInjectionTokenReturn<TReturn, true>[0],
+    createProvideFn(
+      token,
+      () => null!,
+      (options || {}) as CreateProvideFnOptions<() => void, []>,
+    ) as CreateInjectionTokenReturn<TReturn, true>[1],
+    token,
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    () => {},
+  ] as CreateInjectionTokenReturn<TReturn, true>
+}