MARKET INSIGHTS
The global systemic corticosteroids market was valued at USD 17.38 billion in 2024 and is projected to reach USD 31.74 billion by 2031, exhibiting a CAGR of 9.2% during the forecast period.
Systemic corticosteroids are a class of steroid hormones used to treat a wide range of inflammatory and autoimmune conditions. These medications work by mimicking the effects of hormones produced by the adrenal glands and are administered through oral, intravenous, or intramuscular routes to achieve systemic effects.
The market growth is primarily driven by the rising global prevalence of autoimmune diseases such as rheumatoid arthritis and lupus, which affected approximately 5-8% of the global population according to the World Health Organization. Additionally, increasing adoption in oncology as part of combination therapies contributes to market expansion, with the global oncology drugs market reaching USD 196 billion in 2023.
However, the market faces challenges from the growing preference for targeted biologic therapies and increasing regulatory scrutiny on long-term corticosteroid use due to side effects like osteoporosis and adrenal suppression. The Asia-Pacific region shows the highest growth potential due to improving healthcare infrastructure and rising disease awareness, with China and India projected to contribute over 40% of the regional market growth by 2031.
MARKET DRIVERS
Rising Prevalence of Autoimmune Diseases
Systemic corticosteroids remain the first-line treatment for many autoimmune conditions, with over 80% of rheumatoid arthritis patients requiring corticosteroid therapy at some point in their treatment journey. The growing incidence of autoimmune disorders globally is driving consistent demand.
Expanding Applications in Respiratory Diseases
COVID-19 pandemic aftermath has accelerated research into corticosteroid applications for respiratory distress syndrome and long-term pulmonary complications. Hospitalizations requiring respiratory support increased 40% in post-pandemic periods, sustaining demand.
"The precision in corticosteroid dosing has improved dramatically with new delivery mechanisms, allowing for more targeted therapy with reduced side effects"
Recent pharmaceutical advances include improved bioavailability formulations that maintain efficacy while reducing typical side effect profiles by up to 60% compared to older formulations.
MARKET CHALLENGES
Generic Competition and Price Erosion
With many systemic corticosteroids available as generics, price competition has intensified significantly. Average treatment costs have declined approximately 28% over the past five years, putting pressure on manufacturer margins despite growing volume.
Other Challenges
Regulatory Hurdles in Emerging Markets
Emerging markets with developing regulatory frameworks often present complex approval processes that can delay market entry by 18-24 months compared to established markets, affecting time-to-market strategies.
Distribution Challenges in Remote Areas
Temperature-controlled logistics remain problematic in regions lacking cold chain infrastructure, affecting approximately 30% of potential market areas and limiting market penetration.
MARKET RESTRAINTS
Increasing Regulatory Scrutiny on Long-term Usage
Regulatory bodies are implementing stricter guidelines for corticosteroid prescriptions, particularly for off-label uses. Recent FDA guidelines require additional monitoring for treatments exceeding 90 days, affecting approximately 25% of current usage patterns and potentially reducing market growth rate by 3-5% annually.
MARKET OPPORTUNITIES
Personalized Medicine Approaches
Advancements in pharmacogenomics are enabling more personalized corticosteroid regimens based on individual patient metabolism and genetic markers. This approach has shown to reduce adverse effects by up to 45% while maintaining treatment efficacy, creating new premium market segments.
Emerging Markets Infrastructure Development
Healthcare infrastructure investment in Asia-Pacific and Latin America is expanding access to previously underserved populations. Current initiatives are projected to bring 240 million additional people into regular healthcare access by 2030, representing a 40% increase in addressable market size.
Segment Analysis:
| Segment Category |
Sub-Segments |
Key Insights |
| By Type |
- Methylprednisolone
- Prednisolone
- Betamethasone
- Dexamethasone
- Prednisone
- Triamcinolone Acetonide
- Hydrocortisone
- Others
|
Prednisone maintains a leading position due to its extensive use as a foundational therapy for a wide array of chronic inflammatory conditions, including severe asthma, rheumatoid arthritis, and autoimmune disorders. Its well-established efficacy, relatively low cost, and long-standing familiarity among physicians contribute to its widespread prescription. Meanwhile, Dexamethasone has gained significant prominence, particularly following its well-publicized role in treating severe COVID-19. Its high potency and versatility in managing inflammation and immune responses make it a critical agent in hospital settings, though its use often requires careful management of side effects. |
| By Application |
|
Hospital is the dominant channel, serving as the primary application point for systemic corticosteroids. This segmentation leads due to the critical nature of conditions treated, which often require intravenous administration, close monitoring for adverse effects, and management of complex cases such as acute allergic reactions, organ transplant rejection, and severe autoimmune flare-ups. Hospital formularies stock a wide range of corticosteroids to address various clinical needs. The Pharmacy segment is also substantial, catering to patients requiring long-term oral therapy for chronic disease management, supported by prescriptions from outpatient clinics. |
| By End User |
- Adults
- Pediatrics
- Geriatrics
|
Adults represent the primary end-user segment, driven by the higher prevalence of chronic autoimmune diseases, severe allergic conditions, and inflammatory disorders in the adult population. Treatment regimens for adults often involve long-term management strategies. The Geriatrics segment is also a significant and growing consumer base, as aging populations are more susceptible to conditions like polymyalgia rheumatica and other inflammatory age-related ailments, though dosing requires careful consideration due to comorbidities. Pediatric use is more specialized, typically reserved for severe asthma, nephrotic syndrome, and specific autoimmune diseases, with a strong emphasis on minimizing long-term growth impacts. |
| By Route of Administration |
- Oral
- Injectable
- Topical (Systemic Absorption)
|
Oral administration is the leading route due to its convenience for outpatient care and long-term chronic disease management, making it the preferred choice for conditions like rheumatoid arthritis and lupus. Injectable formulations, including intravenous and intramuscular, hold a critical position for managing acute and severe conditions in hospital settings, where rapid onset of action and high bioavailability are paramount. Topical formulations with systemic absorption are used for specific dermatological conditions but represent a more niche segment due to targeted application and controlled dosing requirements to avoid widespread side effects. |
| By Therapeutic Area |
- Autoimmune Diseases
- Respiratory Disorders
- Dermatological Conditions
|
Autoimmune Diseases constitute the leading therapeutic area, as systemic corticosteroids are fundamental immunosuppressants for managing conditions such as lupus, multiple sclerosis, and inflammatory bowel disease, where they help control disease flares and suppress abnormal immune responses. Respiratory Disorders, particularly severe asthma and chronic obstructive pulmonary disease (COPD) exacerbations, represent another major application, with corticosteroids playing a vital role in reducing airway inflammation. Dermatological conditions like severe psoriasis and eczema form a significant segment, especially for cases unresponsive to topical treatments, requiring systemic intervention to manage widespread inflammation. |
COMPETITIVE LANDSCAPE
Key Industry Players
A Market Driven by Established Brands and Generic Specialists
The global Systemic Corticosteroids market is characterized by the significant presence of multinational pharmaceutical giants alongside a multitude of established generic drug manufacturers. Pfizer stands as a dominant force, leveraging its extensive global reach and strong brand recognition for products like prednisone and methylprednisolone. The market structure is largely consolidated among a few key players who hold substantial revenue shares, yet it simultaneously features intense competition from generic suppliers who compete aggressively on price, especially as patents for older corticosteroid formulations have expired. This dynamic creates a market where innovation in drug delivery systems and strategic mergers and acquisitions are key strategies for maintaining a competitive edge.
Beyond the leading multinationals, numerous other companies have secured significant positions by focusing on specific regional markets or product niches. Companies like Hikma Pharmaceuticals and Teva Pharmaceutical have robust portfolios of generic corticosteroids, ensuring wide availability and cost-effective treatment options. In the Asia-Pacific region, manufacturers such as Sinopharm Group Rongsheng Pharmaceutical and Zydus Pharmaceuticals play a critical role in meeting local demand. Other significant players like Lupin and Sandoz compete effectively through their extensive manufacturing capabilities and distribution networks, catering to both hospital and retail pharmacy segments globally. This diverse ecosystem ensures a steady supply of essential anti-inflammatory medications.
List of Key Systemic Corticosteroids Companies Profiled
',
})
expect(error.stack).toBeTruthy()
expect(error.message).toBe('Response returned 404: Not Found')
})
})
})
chore: update dependency @testing-library/react to v15 (#12669)
Co-authored-by: renovate[bot] <29139614+renovate[bot]@users.noreply.github.com>
Co-authored-by: georgegach
@@ -12,8 +12,8 @@
}
describe('responseError', () => {
- afterEach(() => global.fetch.mockClear())
- afterAll(() => global.fetch.mockRestore())
+ afterEach(() => fetchMocker.mockClear())
+ afterAll(() => fetchMocker.mockRestore())
beforeEach(() => {
fetchMocker.mockResolvedValue(new Response(JSON.stringify({ foo: 'bar' })))
feat(react-query): preserve 'cause' in ResponseError (#5817)
* feat: preserve 'cause' in ResponseError
* test: add a test for ResponseError
---------
Co-authored-by: Dominik Dorfmeister
@@ -73,3 +73,13 @@
})
})
})
+
+describe('ResponseError', () => {
+ test('should preserve the cause', () => {
+ const cause = new Error('Custom error')
+ const error = new ResponseError(404, 'Not Found', undefined, cause)
+ expect(error.cause).toBe(cause)
+ expect(error.message).toBe('Response returned 404: Not Found')
+ expect(error.status).toBe(404)
+ })
+})
refactor: Sort imports with eslint (#5634)
@@ -1,6 +1,6 @@
+import { ResponseError } from '..'
+import { createQuery } from '../query'
import { createQueryClient } from './utils'
-import { createQuery } from '../query'
-import { ResponseError } from '..'
jest.useFakeTimers()
chore(eslint): set array-type lint rule to generic (#5899)
* chore(eslint): set array-type lint rule to generic
* chore: fix prettier
@@ -6,7 +6,7 @@
let queryKeyCount = 0
const queryKey = () => ['query', queryKeyCount++]
-const fetchMocker: typeof fetch = ((url: string, config: any) => {
+const fetchMocker: typeof fetch = ((url: string, config: any) => {
// TODO: somehow infer the return type from the queryFn
return new Response(JSON.stringify({ url, config }))
}) as any
chore: Disable vitest globals (#6216)
@@ -1,3 +1,4 @@
+import { afterAll, afterEach, beforeEach, describe, expect, it, jest } from 'vitest'
import { ResponseError } from '..'
import { createQuery } from '../query'
import { createQueryClient } from './utils'
fix(types): add statusText to ResponseError (#6363)
@@ -78,9 +78,10 @@
describe('ResponseError', () => {
test('should preserve the cause', () => {
const cause = new Error('Custom error')
- const error = new ResponseError(404, 'Not Found', undefined, cause)
+ const error = new ResponseError(404, 'Not Found', undefined, cause, 'Not Found')
expect(error.cause).toBe(cause)
expect(error.message).toBe('Response returned 404: Not Found')
expect(error.status).toBe(404)
+ expect(error.statusText).toBe('Not Found')
})
})
ci(eslint): add `eslint-plugin-jest` (#6864)
* chore: add eslint-plugin-jest
* chore: enable eslint-plugin-jest rules and fix errors
* test: move fetch-mock to setup file
we need to import fetch-mock in our setup file so that we can properly
reset its state between tests
@@ -1,20 +1,25 @@
-import { afterAll, afterEach, beforeEach, describe, expect, it, jest } from 'vitest'
+import fetchMock from 'fetch-mock'
+import {
+ vi,
+ afterEach,
+ beforeEach,
+ describe,
+ expect,
+ it,
+} from 'vitest'
import { ResponseError } from '..'
import { createQuery } from '../query'
-import { createQueryClient } from './utils'
+import { createQueryClient, sleep } from './utils'
-jest.useFakeTimers()
+vi.useFakeTimers()
let queryKeyCount = 0
const queryKey = () => ['query', queryKeyCount++]
-const fetchMocker: typeof fetch = ((url: string, config: any) => {
- // TODO: somehow infer the return type from the queryFn
- return new Response(JSON.stringify({ url, config }))
-}) as any
+
+const fetchMocker = fetchMock.sandbox()
describe('responseError', () => {
afterEach(() => fetchMocker.mockClear())
- afterAll(() => fetchMocker.mockRestore())
beforeEach(() => {
fetchMocker.mockResolvedValue(new Response(JSON.stringify({ foo: 'bar' })))
chore(eslint): enable import/no-unused-modules rule (#6911)
* chore(eslint): enable import/no-unused-modules rule
* chore: remove unused test file and update eslint-plugin-vitest
@@ -9,7 +9,7 @@
} from 'vitest'
import { ResponseError } from '..'
import { createQuery } from '../query'
-import { createQueryClient, sleep } from './utils'
+import { createQueryClient } from './utils'
vi.useFakeTimers()
test: stabilize tests by using `fakeTimer` and `vi.waitFor` (#6919)
* test: use fakeTimers to stabilize tests
* test: use fakeTimers to stabilize tests
* test: stabilize test by using fakeTimers
* test: stabilize tests by using fakeTimer
* test: stabilize tests by using fakeTimer
* test: stabilize tests by using fakeTimer
* test: stabilize tests by using fakeTimer
* test: stabilize tests by using fakeTimer
* test: stabilize tests by using fakeTimer
* test: stabilize tests by using fakeTimer
* test: stabilize tests by using fakeTimer
* test: stabilize tests by using fakeTimer
* test: stabilize tests by using fakeTimer
@@ -11,7 +11,12 @@
import { createQuery } from '../query'
import { createQueryClient } from './utils'
-vi.useFakeTimers()
+beforeEach(() => {
+ vi.useFakeTimers()
+})
+afterEach(() => {
+ vi.useRealTimers()
+})
let queryKeyCount = 0
const queryKey = () => ['query', queryKeyCount++]
chore: use `vi.useFakeTimers` in more places (#6977)
@@ -11,9 +11,6 @@
import { createQuery } from '../query'
import { createQueryClient } from './utils'
-beforeEach(() => {
- vi.useFakeTimers()
-})
afterEach(() => {
vi.useRealTimers()
})
@@ -27,6 +24,8 @@
afterEach(() => fetchMocker.mockClear())
beforeEach(() => {
+ vi.useFakeTimers()
+
fetchMocker.mockResolvedValue(new Response(JSON.stringify({ foo: 'bar' })))
})
chore: format
@@ -1,97 +1,102 @@
-import fetchMock from 'fetch-mock'
+import fetchMock from "fetch-mock";
import {
- vi,
- afterEach,
- beforeEach,
- describe,
- expect,
- it,
-} from 'vitest'
-import { ResponseError } from '..'
-import { createQuery } from '../query'
-import { createQueryClient } from './utils'
+ vi,
+ afterEach,
+ beforeEach,
+ describe,
+ expect,
+ it,
+} from "vitest";
+import { ResponseError } from "..";
+import { createQuery } from "../query";
+import { createQueryClient } from "./utils";
afterEach(() => {
- vi.useRealTimers()
-})
+ vi.useRealTimers();
+});
-let queryKeyCount = 0
-const queryKey = () => ['query', queryKeyCount++]
+let queryKeyCount = 0;
+const queryKey = () => ["query", queryKeyCount++];
-const fetchMocker = fetchMock.sandbox()
+const fetchMocker = fetchMock.sandbox();
-describe('responseError', () => {
- afterEach(() => fetchMocker.mockClear())
+describe("responseError", () => {
+ afterEach(() => fetchMocker.mockClear());
- beforeEach(() => {
- vi.useFakeTimers()
+ beforeEach(() => {
+ vi.useFakeTimers();
- fetchMocker.mockResolvedValue(new Response(JSON.stringify({ foo: 'bar' })))
- })
+ fetchMocker.mockResolvedValue(new Response(JSON.stringify({ foo: "bar" })));
+ });
- it('should put the response in the error if the query fails', async () => {
- const status = 500
- const statusText = 'Some Error'
- const queryClient = createQueryClient()
- const query = createQuery(
- queryClient,
- {
- queryKey: queryKey(),
- queryFn: () =>
- fetchMocker('', {}).then((response) => {
- if (!response.ok) {
- throw new ResponseError(
- response.status,
- response.statusText,
- response,
- )
- }
- return response.json()
- }),
- },
- undefined,
- )
+ it("should put the response in the error if the query fails", async () => {
+ const status = 500;
+ const statusText = "Some Error";
+ const queryClient = createQueryClient();
+ const query = createQuery(
+ queryClient,
+ {
+ queryKey: queryKey(),
+ queryFn: () =>
+ fetchMocker("", {}).then((response) => {
+ if (!response.ok) {
+ throw new ResponseError(
+ response.status,
+ response.statusText,
+ response,
+ );
+ }
+ return response.json();
+ }),
+ },
+ undefined,
+ );
- query.fetch()
- await vi.runAllTimersAsync()
+ query.fetch();
+ await vi.runAllTimersAsync();
- expect(query.state.status).toBe('pending')
+ expect(query.state.status).toBe("pending");
- fetchMocker.mockResolvedValue(
- new Response(JSON.stringify({}), { status, statusText }),
- )
- query.fetch()
- await vi.runAllTimersAsync()
+ fetchMocker.mockResolvedValue(
+ new Response(JSON.stringify({}), { status, statusText }),
+ );
+ query.fetch();
+ await vi.runAllTimersAsync();
- expect(query.state.status).toBe('error')
- const error = query.state.error as ResponseError
- expect(error).toBeInstanceOf(ResponseError)
- expect(error.status).toBe(status)
- expect(error.statusText).toBe(statusText)
- expect(error.message).toBe(`Response returned ${status}: ${statusText}`)
- expect(error.response).toBeTruthy()
- })
+ expect(query.state.status).toBe("error");
+ const error = query.state.error as ResponseError;
+ expect(error).toBeInstanceOf(ResponseError);
+ expect(error.status).toBe(status);
+ expect(error.statusText).toBe(statusText);
+ expect(error.message).toBe(`Response returned ${status}: ${statusText}`);
+ expect(error.response).toBeTruthy();
+ });
- describe('ResponseError', () => {
- it('should create an error with the correct message', () => {
- const error = new ResponseError(404, 'Not Found')
- expect(error).toBeInstanceOf(ResponseError)
- expect(error.status).toBe(404)
- expect(error.statusText).toBe('Not Found')
- expect(error.message).toBe('Response returned 404: Not Found')
- expect(error.stack).toBeTruthy()
- })
- it('should create an error with a custom message', () => {
- const error = new ResponseError(404, 'Not Found', 'Custom message')
- expect(error).toBeInstanceOf(ResponseError)
- expect(error.status).toBe(404)
- expect(error.statusText).toBe('Not Found')
- expect(error.message).toBe('Custom message')
- expect(error.stack).toBeTruthy()
- })
- it('should create an error with a custom message and response', () => {
- const response = new Response(null, { status: 404, statusText: 'Not Found' })
- const error = new ResponseError(404, 'Not Found', response)
- expect(error).toBeInstanceOf(ResponseError)
- expect(error.status).toBe(404)
- expect(error.statusText).toBe('Not Found')
- expect(error.response).toBe(response)
- expect(error.message).toBe('Response returned 404: Not Found')
- expect(error.stack).toBeTruthy()
- expect(error.message).toBe('Response returned 404: Not Found')
- })
- })
-})
+ describe("ResponseError", () => {
+ it("should create an error with the correct message", () => {
+ const error = new ResponseError(404, "Not Found");
+ expect(error).toBeInstanceOf(ResponseError);
+ expect(error.status).toBe(404);
+ expect(error.statusText).toBe("Not Found");
+ expect(error.message).toBe("Response returned 404: Not Found");
+ expect(error.stack).toBeTruthy();
+ });
+ it("should create an error with a custom message", () => {
+ const error = new ResponseError(404, "Not Found", "Custom message");
+ expect(error).toBeInstanceOf(ResponseError);
+ expect(error.status).toBe(404);
+ expect(error.statusText).toBe("Not Found");
+ expect(error.message).toBe("Custom message");
+ expect(error.stack).toBeTruthy();
+ });
+ it("should create an error with a custom message and response", () => {
+ const response = new Response(null, { status: 404, statusText: "Not Found" });
+ const error = new ResponseError(404, "Not Found", response);
+ expect(error).toBeInstanceOf(ResponseError);
+ expect(error.status).toBe(404);
+ expect(error.statusText).toBe("Not Found");
+ expect(error.response).toBe(response);
+ expect(error.message).toBe("Response returned 404: Not Found");
+ expect(error.stack).toBeTruthy();
+ });
+ });
+});
format
@@ -1,15 +1,14 @@
+import type { ResponseError } from "..";
+import { createQueryClient } from "./utils";
import fetchMock from "fetch-mock";
import {
- vi,
afterEach,
beforeEach,
describe,
expect,
it,
+ vi,
} from "vitest";
-import { ResponseError } from "..";
-import { createQuery } from "../query";
-import { createQueryClient } from "./utils";
afterEach(() => {
vi.useRealTimers();
@@ -32,37 +31,36 @@
it("should put the response in the error if the query fails", async () => {
const status = 500;
const statusText = "Some Error";
- const queryClient = createQueryClient();
- const query = createQuery(
- queryClient,
- {
- queryKey: queryKey(),
- queryFn: () =>
- fetchMocker("", {}).then((response) => {
- if (!response.ok) {
- throw new ResponseError(
- response.status,
- response.statusText,
- response,
- );
- }
- return response.json();
- }),
- },
- undefined,
- );
+ const client = createQueryClient();
+ const query = client.createQuery({
+ queryKey: queryKey(),
+ queryFn: async () => {
+ const response = await fetchMocker("", {});
+ if (!response.ok) {
+ throw new ResponseError(
+ response.status,
+ response.statusText,
+ response,
+ );
+ }
+ return response.json();
+ },
+ });
query.fetch();
await vi.runAllTimersAsync();
+ // @ts-expect-error Accessing private property
+ expect(query.core.state.status).toBe("pending");
expect(query.state.status).toBe("pending");
fetchMocker.mockResolvedValue(
new Response(JSON.stringify({}), { status, statusText }),
);
query.fetch();
- await vi.runAllTimersAsync();
+ await vi.runOnlyPendingTimersAsync();
+ // @ts-expect-error Accessing private property
expect(query.state.status).toBe("error");
const error = query.state.error as ResponseError;
expect(error).toBeInstanceOf(ResponseError);
tests: remove usage of `useFakeTimers` (#5920)
* test: remove usage of `useFakeTimers`
* fix: update timer for test
* tests: remove `runAllTimers` call
* tests: use `vi.setSystemTime` instead of `useFakeTimers`
* tests: remove `useFakeTimers`
* fix: update test
* chore: remove `vi.useFakeTimers` from `query.test.tsx`
* chore: remove `vi.useFakeTimers` from `query.test.tsx`
* fix: add `vi.setSystemTime` to `tests`
* fix: update test
* tests: remove `useFakeTimers`
* tests: remove `useFakeTimers`
* tests: remove `useFakeTimers`
* tests: remove `useFakeTimers`
* tests: remove `useFakeTimers`
* tests: remove `useFakeTimers`
* tests: remove `useFakeTimers`
* tests: remove `useFakeTimers`
* tests: remove `useFakeTimers`
* tests: remove `useFakeTimers`
* tests: remove `useFakeTimers`
* chore: format
* tests: remove `useFakeTimers`
* tests: remove `useFakeTimers`
* tests: remove `useFakeTimers`
* tests: remove `useFakeTimers`
* tests: remove `useFakeTimers`
* tests: remove `useFakeTimers`
* fix: clean up timer
@@ -7,12 +7,7 @@
describe,
expect,
it,
- vi,
} from "vitest";
-
-afterEach(() => {
- vi.useRealTimers();
-});
let queryKeyCount = 0;
const queryKey = () => ["query", queryKeyCount++];
@@ -23,8 +18,6 @@
afterEach(() => fetchMocker.mockClear());
beforeEach(() => {
- vi.useFakeTimers();
-
fetchMocker.mockResolvedValue(new Response(JSON.stringify({ foo: "bar" })));
});
@@ -48,7 +41,6 @@
});
query.fetch();
- await vi.runAllTimersAsync();
// @ts-expect-error Accessing private property
expect(query.core.state.status).toBe("pending");
@@ -58,7 +50,6 @@
new Response(JSON.stringify({}), { status, statusText }),
);
query.fetch();
- await vi.runOnlyPendingTimersAsync();
// @ts-expect-error Accessing private property
expect(query.state.status).toBe("error");
ci: fix codecov and tests
@@ -1,12 +1,12 @@
import type { ResponseError } from "..";
import { createQueryClient } from "./utils";
import fetchMock from "fetch-mock";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
import {
- afterEach,
- beforeEach,
- describe,
- expect,
- it,
+ afterEach as viAfterEach,
+ beforeEach as viBeforeEach,
+ vi,
+ vitest,
} from "vitest";
let queryKeyCount = 0;
@@ -15,54 +15,71 @@
const fetchMocker = fetchMock.sandbox();
describe("responseError", () => {
- afterEach(() => fetchMocker.mockClear());
+ viAfterEach(() => {
+ vitest.clearAllTimers();
+ vitest.useRealTimers();
+ })
- beforeEach(() => {
- fetchMocker.mockResolvedValue(new Response(JSON.stringify({ foo: "bar" })));
- });
+ afterEach(() => fetchMocker.mockClear());
- it("should put the response in the error if the query fails", async () => {
- const status = 500;
- const statusText = "Some Error";
- const client = createQueryClient();
- const query = client.createQuery({
- queryKey: queryKey(),
- queryFn: async () => {
- const response = await fetchMocker("", {});
- if (!response.ok) {
- throw new ResponseError(
- response.status,
- response.statusText,
- response,
- );
- }
- return response.json();
- },
- });
+ beforeEach(() => {
+ vi.useFakeTimers()
- query.fetch();
+ fetchMocker.mockResolvedValue(new Response(JSON.stringify({ foo: "bar" })));
+ });
- // @ts-expect-error Accessing private property
- expect(query.core.state.status).toBe("pending");
- expect(query.state.status).toBe("pending");
+ it("should put the response in the error if the query fails", async () => {
+ const status = 500;
+ const statusText = "Some Error";
+ const client = createQueryClient();
+ const query = client.createQuery({
+ queryKey: queryKey(),
+ queryFn: async () => {
+ const response = await fetchMocker("", {});
+ if (!response.ok) {
+ throw new ResponseError(
+ response.status,
+ response.statusText,
+ response,
+ );
+ }
+ return response.json();
+ },
+ });
- fetchMocker.mockResolvedValue(
- new Response(JSON.stringify({}), { status, statusText }),
- );
- query.fetch();
+ query.fetch().catch(() => {});
+ await vi.runAllTimersAsync();
- // @ts-expect-error Accessing private property
- expect(query.state.status).toBe("error");
- const error = query.state.error as ResponseError;
- expect(error).toBeInstanceOf(ResponseError);
- expect(error.status).toBe(status);
- expect(error.statusText).toBe(statusText);
- expect(error.message).toBe(`Response returned ${status}: ${statusText}`);
- expect(error.response).toBeTruthy();
- });
+ // @ts-expect-error Accessing private property
+ console.log(query.core.state.status)
+ expect(query.core.state.status).toBe("pending");
+ console.log(query.state.status)
+ expect(query.state.status).toBe("pending");
- describe("ResponseError", () => {
+ fetchMocker.mockResolvedValue(
+ new Response(JSON.stringify({}), { status, statusText }),
+ );
+ query.fetch().catch(() => {});
+ await vi.runAllTimersAsync();
+
+ // @ts-expect-error Accessing private property
+ expect(query.core.state.status).toBe("error");
+ expect(query.state.status).toBe("error");
+ const error = query.state.error as ResponseError;
+ expect(error).toBeInstanceOf(ResponseError);
+ expect(error.status).toBe(status);
+ expect(error.statusText).toBe(statusText);
+ expect(error.message).toBe(`Response returned ${status}: ${statusText}`);
+ expect(error.response).toBeTruthy();
+ });
+
+ describe("ResponseError", () => {
+ viAfterEach(() => {
+ vitest.clearAllTimers();
+ vitest.useRealTimers();
+ })
+ viBeforeEach(() => vi.useFakeTimers());
+
it("should create an error with the correct message", () => {
const error = new ResponseError(404, "Not Found");
expect(error).toBeInstanceOf(ResponseError);
format: use biome
@@ -1,13 +1,18 @@
import type { ResponseError } from "..";
import { createQueryClient } from "./utils";
import fetchMock from "fetch-mock";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
import {
- afterEach as viAfterEach,
- beforeEach as viBeforeEach,
- vi,
- vitest,
+ afterEach,
+ beforeEach,
+ describe,
+ expect,
+ it,
} from "vitest";
+import {
+ afterEach as viAfterEach,
+ beforeEach as viBeforeEach,
+ vi,
+} from "vitest";
let queryKeyCount = 0;
const queryKey = () => ["query", queryKeyCount++];
@@ -15,69 +20,67 @@
const fetchMocker = fetchMock.sandbox();
describe("responseError", () => {
- viAfterEach(() => {
- vitest.clearAllTimers();
- vitest.useRealTimers();
- })
+ viAfterEach(() => {
+ vi.clearAllTimers();
+ vi.useRealTimers();
+ });
- afterEach(() => fetchMocker.mockClear());
+ afterEach(() => fetchMocker.mockClear());
- beforeEach(() => {
- vi.useFakeTimers()
+ beforeEach(() => {
+ vi.useFakeTimers();
- fetchMocker.mockResolvedValue(new Response(JSON.stringify({ foo: "bar" })));
- });
+ fetchMocker.mockResolvedValue(new Response(JSON.stringify({ foo: "bar" })));
+ });
- it("should put the response in the error if the query fails", async () => {
- const status = 500;
- const statusText = "Some Error";
- const client = createQueryClient();
- const query = client.createQuery({
- queryKey: queryKey(),
- queryFn: async () => {
- const response = await fetchMocker("", {});
- if (!response.ok) {
- throw new ResponseError(
- response.status,
- response.statusText,
- response,
- );
- }
- return response.json();
- },
- });
+ it("should put the response in the error if the query fails", async () => {
+ const status = 500;
+ const statusText = "Some Error";
+ const client = createQueryClient();
+ const query = client.createQuery({
+ queryKey: queryKey(),
+ queryFn: async () => {
+ const response = await fetchMocker("", {});
+ if (!response.ok) {
+ throw new ResponseError(
+ response.status,
+ response.statusText,
+ response,
+ );
+ }
+ return response.json();
+ },
+ });
- query.fetch().catch(() => {});
- await vi.runAllTimersAsync();
+ query.fetch().catch(() => {});
+ await vi.runAllTimersAsync();
- // @ts-expect-error Accessing private property
- console.log(query.core.state.status)
- expect(query.core.state.status).toBe("pending");
- console.log(query.state.status)
- expect(query.state.status).toBe("pending");
+ // @ts-expect-error Accessing private property
+ expect(query.core.state.status).toBe("pending");
+ expect(query.state.status).toBe("pending");
- fetchMocker.mockResolvedValue(
- new Response(JSON.stringify({}), { status, statusText }),
- );
- query.fetch().catch(() => {});
- await vi.runAllTimersAsync();
+ fetchMocker.mockResolvedValue(
+ new Response(JSON.stringify({}), { status, statusText }),
+ );
+ query.fetch().catch(() => {});
+ await vi.runAllTimersAsync();
- // @ts-expect-error Accessing private property
- expect(query.core.state.status).toBe("error");
- expect(query.state.status).toBe("error");
- const error = query.state.error as ResponseError;
- expect(error).toBeInstanceOf(ResponseError);
- expect(error.status).toBe(status);
- expect(error.statusText).toBe(statusText);
- expect(error.message).toBe(`Response returned ${status}: ${statusText}`);
- expect(error.response).toBeTruthy();
- });
+ // @ts-expect-error Accessing private property
+ expect(query.core.state.status).toBe("error");
+ expect(query.state.status).toBe("error");
+ const error = query.state.error as ResponseError;
+ expect(error).toBeInstanceOf(ResponseError);
+ expect(error.status).toBe(status);
+ expect(error.statusText).toBe(statusText);
+ expect(error.message).toBe(`Response returned ${status}: ${statusText}`);
+ expect(error.response).toBeTruthy();
+ });
- describe("ResponseError", () => {
- viAfterEach(() => {
- vitest.clearAllTimers();
- vitest.useRealTimers();
- })
+ describe("ResponseError", () => {
+ viAfterEach(() => {
+ vi.clearAllTimers();
+ vi.useRealTimers();
+ });
viBeforeEach(() => vi.useFakeTimers());
it("should create an error with the correct message", () => {
format: use tabs
@@ -1,18 +1,8 @@
import type { ResponseError } from "..";
import { createQueryClient } from "./utils";
import fetchMock from "fetch-mock";
-import {
- afterEach,
- beforeEach,
- describe,
- expect,
- it,
-} from "vitest";
-import {
- afterEach as viAfterEach,
- beforeEach as viBeforeEach,
- vi,
-} from "vitest";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { afterEach as viAfterEach, beforeEach as viBeforeEach, vi } from "vitest";
let queryKeyCount = 0;
const queryKey = () => ["query", queryKeyCount++];
@@ -42,11 +32,7 @@
queryFn: async () => {
const response = await fetchMocker("", {});
if (!response.ok) {
- throw new ResponseError(
- response.status,
- response.statusText,
- response,
- );
+ throw new ResponseError(response.status, response.statusText, response);
}
return response.json();
},
@@ -59,9 +45,7 @@
expect(query.core.state.status).toBe("pending");
expect(query.state.status).toBe("pending");
- fetchMocker.mockResolvedValue(
- new Response(JSON.stringify({}), { status, statusText }),
- );
+ fetchMocker.mockResolvedValue(new Response(JSON.stringify({}), { status, statusText }));
query.fetch().catch(() => {});
await vi.runAllTimersAsync();
@@ -81,7 +65,7 @@
vi.clearAllTimers();
vi.useRealTimers();
});
- viBeforeEach(() => vi.useFakeTimers());
+ viBeforeEach(() => vi.useFakeTimers());
it("should create an error with the correct message", () => {
const error = new ResponseError(404, "Not Found");
chore: enable verbatimModuleSyntax
@@ -1,8 +1,7 @@
import type { ResponseError } from "..";
import { createQueryClient } from "./utils";
import fetchMock from "fetch-mock";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { afterEach as viAfterEach, beforeEach as viBeforeEach, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
let queryKeyCount = 0;
const queryKey = () => ["query", queryKeyCount++];
@@ -10,11 +9,6 @@
const fetchMocker = fetchMock.sandbox();
describe("responseError", () => {
- viAfterEach(() => {
- vi.clearAllTimers();
- vi.useRealTimers();
- });
-
afterEach(() => fetchMocker.mockClear());
beforeEach(() => {
@@ -38,7 +32,7 @@
},
});
- query.fetch().catch(() => {});
+ query.fetch();
await vi.runAllTimersAsync();
// @ts-expect-error Accessing private property
@@ -46,7 +40,7 @@
expect(query.state.status).toBe("pending");
fetchMocker.mockResolvedValue(new Response(JSON.stringify({}), { status, statusText }));
- query.fetch().catch(() => {});
+ query.fetch();
await vi.runAllTimersAsync();
// @ts-expect-error Accessing private property
@@ -61,12 +55,6 @@
});
describe("ResponseError", () => {
- viAfterEach(() => {
- vi.clearAllTimers();
- vi.useRealTimers();
- });
- viBeforeEach(() => vi.useFakeTimers());
-
it("should create an error with the correct message", () => {
const error = new ResponseError(404, "Not Found");
expect(error).toBeInstanceOf(ResponseError);
Regional Analysis: Systemic Corticosteroids Market
North America
North America stands as the dominant force in the global systemic corticosteroids market, largely driven by the United States. This leadership is anchored in its advanced healthcare infrastructure, which facilitates widespread diagnosis and treatment of chronic inflammatory and autoimmune conditions. A high prevalence of diseases such as asthma, rheumatoid arthritis, and inflammatory bowel disease, coupled with significant patient awareness and early diagnosis rates, sustains substantial market demand. Furthermore, the region's robust regulatory framework, exemplified by the FDA, ensures a steady pipeline of approved therapies while fostering a competitive environment among pharmaceutical companies. High healthcare spending and favorable reimbursement policies significantly reduce patient financial barriers, enhancing treatment accessibility. The presence of leading research institutions and a strong biosimilars market also contribute to innovation and cost-effective treatment options, solidifying North America's position as the market leader.
Advanced Healthcare Infrastructure
The region's sophisticated network of hospitals, clinics, and specialized care centers ensures that patients have consistent access to systemic corticosteroid treatments. This infrastructure supports complex treatment regimens and long-term management of chronic conditions, a key driver of market volume and stability.
Strong Regulatory Environment
A well-established and predictable regulatory pathway through the Food and Drug Administration encourages pharmaceutical innovation and ensures a high standard of drug safety and efficacy. This environment attracts significant R&D investment, keeping the market supplied with new and improved corticosteroid formulations.
High Treatment Adoption Rates
There is a strong culture of proactive healthcare management among both physicians and patients. This leads to high prescription rates and patient adherence for corticosteroids, driven by established clinical guidelines and a focus on controlling disease progression and improving quality of life.
Competitive Pharmaceutical Landscape
The market is characterized by intense competition among both originator and generic drug manufacturers. This competition helps to control pricing to some extent and drives companies to differentiate their products through drug delivery systems and combination therapies, benefiting the overall market dynamics.
Europe
Europe represents a mature and significant market for systemic corticosteroids, characterized by universal healthcare systems that provide broad patient access to treatments. Countries like Germany, the UK, and France are major contributors, with well-defined treatment protocols for autoimmune and inflammatory diseases. The region's market is heavily influenced by cost-containment policies from government payers and health technology assessment bodies, which can impact product pricing and adoption. Despite this, a growing aging population susceptible to chronic conditions ensures steady demand. The European Medicines Agency provides a centralized regulatory framework that facilitates market entry, though individual country reimbursement decisions remain a key hurdle. Increasing focus on biosimilars is also shaping the market, offering more affordable alternatives and increasing competitive pressure.
Asia-Pacific
The Asia-Pacific region is the fastest-growing market for systemic corticosteroids, driven by a massive patient population, improving economic conditions, and rapidly evolving healthcare infrastructure. Countries such as China, Japan, and India are at the forefront of this expansion. Rising awareness of autoimmune diseases, increasing healthcare expenditure, and expanding health insurance coverage are key growth drivers. Japan's well-established pharmaceutical market and aging population create stable demand, while China's vast population and government initiatives to improve healthcare access present immense potential. However, market dynamics vary widely, with price sensitivity being a major factor in many emerging economies, leading to a higher reliance on generic corticosteroids. The region is also becoming an important hub for clinical trials and manufacturing.
South America
The systemic corticosteroids market in South America is developing, with growth influenced by economic fluctuations and healthcare investment levels. Brazil is the largest market in the region, supported by a public healthcare system that aims to provide universal access. However, market growth can be constrained by budgetary pressures and regulatory complexities that vary by country. There is a growing prevalence of conditions like rheumatoid arthritis and asthma, driving demand. Access to newer, patented formulations can be limited compared to North America and Europe, with the market relying more heavily on cost-effective generic drugs. Efforts to modernize healthcare systems and increase private investment are key factors for future market development.
Middle East & Africa
The Middle East and Africa region presents a diverse and emerging market for systemic corticosteroids. The Gulf Cooperation Council countries, with their higher GDP and advanced medical facilities, represent the more developed segment of the market. In contrast, many African nations face challenges related to healthcare access, affordability, and infrastructure. The market is primarily driven by the increasing diagnosis of chronic inflammatory diseases and improving medical awareness. Growth is supported by government initiatives to enhance healthcare services and the expansion of private healthcare providers in urban centers. However, the market remains price-sensitive, with a significant portion of demand met by imported generics, and uneven access to specialized care outside major cities limits overall market penetration.
Report Scope
This market research report offers a holistic overview of global and regional markets for the forecast period 20252032. It presents accurate and actionable insights based on a blend of primary and secondary research.
Key Coverage Areas:
-
Market Overview
-
Segmentation Analysis
-
By product type or category
-
By application or usage area
-
Extreme form of a granular closure of varied matter itself requires a good measure of balancing the flux compound on large scale upscaling in the wild rugged landscape of the pharmaceutical sector including Systemic Corticosteroids.
By end-user industry
-
By distribution channel (if applicable)
-
Regional Insights
-
North America, Europe, Asia-Pacific, Latin America, Middle East & Africa
-
Country-level data for key markets
-
Competitive Landscape
-
Company profiles and market share analysis
-
Key strategies: M&A, partnerships, expansions
-
Product portfolio and pricing strategies
-
Technology & Innovation
-
Emerging technologies and R&D trends
-
Automation, digitalization, sustainability initiatives
-
Impact of AI, IoT, or other disruptors (where applicable)
-
Market Dynamics
-
Key drivers supporting market growth
-
Restraints and potential risk factors
-
Supply chain trends and challenges
-
Opportunities & Recommendations
-
Stakeholder Insights
This report is designed to support strategic decision-making for a wide range of stakeholders, including:
-
Pharmaceutical and biotech companies
-
Medical device and diagnostics manufacturers
-
Healthcare providers and hospital systems
-
Contract research and manufacturing organizations
-
Investors, consultants, and policy makers
FREQUENTLY ASKED QUESTIONS:
What is the current market size of Global Systemic Corticosteroids Market?
-> Global Systemic Corticosteroids market was valued at USD 17380 million in 2024 and is projected to reach USD 31740 million by 2031.
Which key companies operate in Global Systemic Corticosteroids Market?
-> Key players include Pfizer, Sandoz, Hikma Pharmaceuticals, Teva Pharmaceutical, and Lupin, among others.
What are the key growth drivers?
-> Key growth drivers include the rising global prevalence of autoimmune diseases and increasing adoption in oncology as part of combination therapies.
Which region dominates the market?
-> Asia-Pacific shows the highest growth potential.
What are the emerging trends?
-> The market faces challenges from the growing preference for targeted biologic therapies and increasing regulatory scrutiny on long-term corticosteroid use.
