Method resolveRefs

src/openapi-loader.ts:89–133

(
    value: unknown,
    context: {
      currentSource: string;
      currentDocument: unknown;
      rawDocCache: Map<string, unknown>;
      resolvingRefs: Set<string>;
    }
  )

  }

  private async resolveRefs(
    value: unknown,
    context: {
      currentSource: string;
      currentDocument: unknown;
      rawDocCache: Map<string, unknown>;
      resolvingRefs: Set<string>;
    }
  ): Promise<unknown> {
    if (Array.isArray(value)) {
      const items = await Promise.all(value.map((item) => this.resolveRefs(item, context)));
      return items;
    }

    if (!value || typeof value !== "object") {
      return value;
    }

    const record = value as Record<string, unknown>;
    const ref = record.$ref;

    if (typeof ref === "string") {
      const siblingEntries = Object.entries(record).filter(([key]) => key !== "$ref");
      const resolvedRef = await this.resolveRef(ref, context);
      const resolvedSiblings = Object.fromEntries(
        await Promise.all(
          siblingEntries.map(async ([key, siblingValue]) => [key, await this.resolveRefs(siblingValue, context)] as const)
        )
      );

      if (resolvedRef && typeof resolvedRef === "object" && !Array.isArray(resolvedRef)) {
        return {
          ...(resolvedRef as Record<string, unknown>),
          ...resolvedSiblings,
        };
      }

      return Object.keys(resolvedSiblings).length > 0 ? resolvedSiblings : resolvedRef;
    }

    const resolvedEntries = await Promise.all(
      Object.entries(record).map(async ([key, nested]) => [key, await this.resolveRefs(nested, context)] as const)
    );
    return Object.fromEntries(resolvedEntries);
  }

  private async resolveRef(
    ref: string,