Function extendIntegration

packages/core/src/integration.ts:206–241

(
  integration: Base,
  extendedIntegration: Extended,
)

 * ```
 */
export function extendIntegration<Base extends Integration, Extended extends Partial<IntegrationWithOtherProperties>>(
  integration: Base,
  extendedIntegration: Extended,
): ExtendedIntegration<Base, Extended> {
  // The extension overrides the base for any shared key (object spread + the wrapping below), so the
  // result type drops the overridden base keys rather than intersecting them — `Base & Extended` would
  // wrongly intersect shared keys (e.g. a re-typed property collapses to `never`).
  const wrappedIntegration = {
    ...integration,
    ...extendedIntegration,
  } as ExtendedIntegration<Base, Extended>;

  // Make sure that functions that are extended also call the base functions, if defined
  // oxlint-disable-next-line guard-for-in
  for (const key in extendedIntegration) {
    const baseValue = integration[key as keyof Base];
    const extendedValue = extendedIntegration[key];

    type ValueType = typeof extendedValue;

    if (typeof baseValue === 'function' && typeof extendedValue === 'function') {
      const wrappedFunction = new Proxy(baseValue, {
        apply: (target, thisArg, args) => {
          Reflect.apply(target, thisArg, args);
          return Reflect.apply(extendedValue, thisArg, args);
        },
      }) as ValueType;

      // We know this is OK, but typescript does not properly narrow/infer types here
      // so instead of casting the wrappedFunction to some complicated type, we just make clear that we simply overwrite this
      (wrappedIntegration as Record<string, unknown>)[key] = wrappedFunction;
    }
  }

  return wrappedIntegration;
}