@r0hitsharma/http-client-msw 0.12.0-rohit-fork-ci.1

package/dist/mock-delay.js

@@ -0,0 +1,50 @@
+/**
+ * Latency is what makes a mock exercise the states a real API forces an app
+ * through — pending spinners, skeletons, optimistic UI, race conditions. The same
+ * latency in a test suite is dead time, so the amount is per-environment and the
+ * default under test is none.
+ */
+/**
+ * True when running under a test runner: `NODE_ENV === 'test'` (vitest, jest) or
+ * Vite's `MODE === 'test'`. Read defensively because neither `process` nor
+ * `import.meta.env` exists in every environment this package runs in.
+ */
+export function isTestEnvironment() {
+    // `process.env` is optional-chained as well as guarded: a browser shim that
+    // defines `process` without an `env` would otherwise throw from inside a
+    // request handler. The dot form is deliberate — it is what bundlers rewrite.
+    const nodeEnv = typeof process === 'undefined' ? undefined : process.env?.NODE_ENV;
+    const viteMode = import.meta.env
+        ?.MODE;
+    return nodeEnv === 'test' || viteMode === 'test';
+}
+/** The pure resolution `mockDelay` applies, split out so both branches are testable. */
+export function resolveMockDelay(input, isTest) {
+    if (typeof input === 'number')
+        return isTest ? 0 : input;
+    return (isTest ? input.test : input.dev) ?? 0;
+}
+/**
+ * Waits, in dev; resolves immediately under test unless a test delay is asked
+ * for.
+ *
+ * ```ts
+ * mock.get('/things', async ({ response }) => {
+ *   await mockDelay(400);
+ *   return response(200).json(things.list());
+ * });
+ *
+ * // Keep a little latency under test, for a pending-state assertion.
+ * await mockDelay({ dev: 400, test: 10 });
+ * ```
+ */
+export function mockDelay(input = 0) {
+    const ms = resolveMockDelay(input, isTestEnvironment());
+    // No timer at all for a zero delay: a mock that resolves in the same
+    // microtask keeps a suite's timing behaviour unchanged.
+    if (ms <= 0)
+        return Promise.resolve();
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}

package/dist/mock-store.d.ts

@@ -0,0 +1,76 @@
+/**
+ * The smallest amount of state a mock needs to behave like an API rather than a
+ * fixture dump: a POST that shows up in the following GET. Deliberately not a
+ * database — no queries, no indexes, no relations. A mock that needs those is a
+ * mock standing in for logic the real service owns.
+ */
+export type MockStoreOptions<T> = {
+    /**
+     * How an item's identity is read. Defaults to its `id` property, which must be
+     * a string or a number.
+     */
+    id?: (item: T) => string;
+};
+/**
+ * Aliasing, since it is observable: `get`, `insert`, and the elements of
+ * `list` are the **stored** objects, so mutating one writes through to the
+ * store — only `list`'s array is a copy. `update` replaces the item with
+ * a merged copy instead, which leaves any reference taken before the update
+ * stale. Read again after an update rather than holding a reference across one.
+ */
+export type MockStore<T> = {
+    /**
+     * Every item, in insertion order. The array is fresh, so sorting, slicing, or
+     * splicing it cannot reorder the store — but its elements are the stored
+     * objects, not copies, so mutating one writes through like `get` does.
+     */
+    list: () => T[];
+    get: (id: string) => T | undefined;
+    has: (id: string) => boolean;
+    readonly size: number;
+    /** Adds an item. Throws on a duplicate id, which is a fixture bug rather than an API condition. */
+    insert: (item: T) => T;
+    /**
+     * Merges `patch` into an existing item, keeping its position. `undefined`
+     * when the id is unknown — a handler turns that into its own 404.
+     *
+     * A patch may carry the id, which moves the item to it; the old id then
+     * misses. Throws if that id is already taken, like `insert`, and leaves the
+     * store untouched when it does.
+     */
+    update: (id: string, patch: Partial<T>) => T | undefined;
+    /** `false` when the id is unknown. */
+    remove: (id: string) => boolean;
+    /** Swaps in a whole collection. Throws if two items share an id, like `insert`. */
+    replaceAll: (items: readonly T[]) => void;
+    /** Re-seeds from the seed function. Pass this to `setupMocks({ onReset })`. */
+    reset: () => void;
+};
+/**
+ * An in-memory collection whose `reset` restores the seeded contents.
+ *
+ * The seed is a **function**, called on construction and again on every reset, so
+ * a handler that mutates an item in place cannot corrupt the next test's
+ * starting point. That holds only if the function *constructs* its items — a
+ * seed that returns a shared module-level array hands out the same objects every
+ * time, and a mutation to one of those does survive a reset.
+ *
+ * ```ts
+ * const things = createMockStore(seedThings);
+ *
+ * export const mocks = setupMocks(
+ *   [
+ *     mock.get('/things', ({ response }) => response(200).json(things.list())),
+ *     mock.get('/things/{id}', ({ params, response }) => {
+ *       const thing = things.get(params.id);
+ *
+ *       return thing
+ *         ? response(200).json(thing)
+ *         : response(404).json({ message: 'not found' });
+ *     }),
+ *   ],
+ *   { onReset: [things.reset] },
+ * );
+ * ```
+ */
+export declare function createMockStore<T>(seed: () => readonly T[], options?: MockStoreOptions<T>): MockStore<T>;

package/dist/mock-store.js

@@ -0,0 +1,114 @@
+/**
+ * The smallest amount of state a mock needs to behave like an API rather than a
+ * fixture dump: a POST that shows up in the following GET. Deliberately not a
+ * database — no queries, no indexes, no relations. A mock that needs those is a
+ * mock standing in for logic the real service owns.
+ */
+function defaultIdOf(item) {
+    const id = item.id;
+    if (typeof id === 'string')
+        return id;
+    if (typeof id === 'number')
+        return String(id);
+    throw new Error('http-client-msw: createMockStore items need a string or number `id`, or an explicit `id` selector');
+}
+/**
+ * An in-memory collection whose `reset` restores the seeded contents.
+ *
+ * The seed is a **function**, called on construction and again on every reset, so
+ * a handler that mutates an item in place cannot corrupt the next test's
+ * starting point. That holds only if the function *constructs* its items — a
+ * seed that returns a shared module-level array hands out the same objects every
+ * time, and a mutation to one of those does survive a reset.
+ *
+ * ```ts
+ * const things = createMockStore(seedThings);
+ *
+ * export const mocks = setupMocks(
+ *   [
+ *     mock.get('/things', ({ response }) => response(200).json(things.list())),
+ *     mock.get('/things/{id}', ({ params, response }) => {
+ *       const thing = things.get(params.id);
+ *
+ *       return thing
+ *         ? response(200).json(thing)
+ *         : response(404).json({ message: 'not found' });
+ *     }),
+ *   ],
+ *   { onReset: [things.reset] },
+ * );
+ * ```
+ */
+export function createMockStore(seed, options = {}) {
+    const idOf = options.id ?? defaultIdOf;
+    const items = new Map();
+    /**
+     * Built into a staging map first, so the duplicate-id check that `insert`
+     * enforces also covers construction and every reset — and so a rejected
+     * collection leaves the store as it was rather than half-cleared.
+     */
+    const replaceAll = (next) => {
+        const replacement = new Map();
+        for (const item of next) {
+            const id = idOf(item);
+            if (replacement.has(id)) {
+                throw new Error(`http-client-msw: createMockStore was given two items with id "${id}"`);
+            }
+            replacement.set(id, item);
+        }
+        items.clear();
+        for (const [id, item] of replacement)
+            items.set(id, item);
+    };
+    replaceAll(seed());
+    return {
+        list: () => [...items.values()],
+        get: (id) => items.get(id),
+        has: (id) => items.has(id),
+        get size() {
+            return items.size;
+        },
+        insert: (item) => {
+            const id = idOf(item);
+            if (items.has(id)) {
+                throw new Error(`http-client-msw: createMockStore already holds an item with id "${id}"`);
+            }
+            items.set(id, item);
+            return item;
+        },
+        update: (id, patch) => {
+            const existing = items.get(id);
+            if (existing === undefined)
+                return undefined;
+            const updated = { ...existing, ...patch };
+            // `Partial<T>` admits the id, so the patch can move the item. Re-derived
+            // rather than assumed, because leaving it under the old key desyncs the
+            // map from the items in it: `get(item.id)` misses and `get(oldId)` hands
+            // back an item that no longer claims that id.
+            const nextId = idOf(updated);
+            if (nextId === id) {
+                items.set(id, updated);
+                return updated;
+            }
+            if (items.has(nextId)) {
+                throw new Error(`http-client-msw: createMockStore already holds an item with id "${nextId}"`);
+            }
+            // Rebuilt in order rather than delete-then-set, which would move the item
+            // to the end: `update` keeps an item's position, and a patched id is
+            // still an update. The collision above throws before anything is
+            // touched, so a rejected patch leaves the store as it was.
+            const entries = [...items];
+            items.clear();
+            for (const [key, item] of entries) {
+                if (key === id)
+                    items.set(nextId, updated);
+                else
+                    items.set(key, item);
+            }
+            return updated;
+        },
+        remove: (id) => items.delete(id),
+        replaceAll,
+        reset: () => replaceAll(seed()),
+    };
+}

package/dist/node.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Node entry: `@r0hitsharma/http-client-msw/node`.
+ *
+ * Kept behind its own subpath so an app bundle never resolves `msw/node`, whose
+ * interceptors patch node's http modules.
+ */
+import { type SetupServer } from 'msw/node';
+import type { MockSetup } from './setup.js';
+export type MockServerOptions = NonNullable<Parameters<SetupServer['listen']>[0]>;
+export type MockServer = {
+    /** The underlying msw server, for `use()` and lifecycle events. */
+    server: SetupServer;
+    /** Starts interception. `onUnhandledRequest` defaults to `'error'`. */
+    listen: (overrides?: MockServerOptions) => void;
+    close: () => void;
+    /** Runs the setup's state resets, then drops runtime handler overrides. */
+    reset: () => void;
+};
+/**
+ * Serves a {@link MockSetup} from msw's node interceptors — the same handler
+ * array a browser worker serves.
+ *
+ * ```ts
+ * // src/test-setup.ts
+ * import { setupMockServer } from '@r0hitsharma/http-client-msw/node';
+ * import { afterAll, afterEach, beforeAll } from 'vitest';
+ *
+ * import { mocks } from './mocks';
+ *
+ * const mockServer = setupMockServer(mocks);
+ *
+ * beforeAll(() => mockServer.listen());
+ * afterEach(() => mockServer.reset());
+ * afterAll(() => mockServer.close());
+ * ```
+ *
+ * `onUnhandledRequest` defaults to `'error'` rather than msw's `'warn'`: in a
+ * test suite an unmocked request is a hole in the fixtures, and a warning that
+ * scrolls past is how a test ends up asserting against real network output.
+ */
+export declare function setupMockServer(mocks: MockSetup): MockServer;

package/dist/node.js

@@ -0,0 +1,41 @@
+/**
+ * Node entry: `@r0hitsharma/http-client-msw/node`.
+ *
+ * Kept behind its own subpath so an app bundle never resolves `msw/node`, whose
+ * interceptors patch node's http modules.
+ */
+import { setupServer } from 'msw/node';
+/**
+ * Serves a {@link MockSetup} from msw's node interceptors — the same handler
+ * array a browser worker serves.
+ *
+ * ```ts
+ * // src/test-setup.ts
+ * import { setupMockServer } from '@r0hitsharma/http-client-msw/node';
+ * import { afterAll, afterEach, beforeAll } from 'vitest';
+ *
+ * import { mocks } from './mocks';
+ *
+ * const mockServer = setupMockServer(mocks);
+ *
+ * beforeAll(() => mockServer.listen());
+ * afterEach(() => mockServer.reset());
+ * afterAll(() => mockServer.close());
+ * ```
+ *
+ * `onUnhandledRequest` defaults to `'error'` rather than msw's `'warn'`: in a
+ * test suite an unmocked request is a hole in the fixtures, and a warning that
+ * scrolls past is how a test ends up asserting against real network output.
+ */
+export function setupMockServer(mocks) {
+    const server = setupServer(...mocks.handlers);
+    return {
+        server,
+        listen: (overrides) => server.listen({ onUnhandledRequest: 'error', ...overrides }),
+        close: () => server.close(),
+        reset: () => {
+            mocks.resetState();
+            server.resetHandlers();
+        },
+    };
+}

package/dist/seeded-rng.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Deterministic randomness for generated fixtures. `Math.random` in a mock makes
+ * a failing test unreproducible and a visual snapshot unstable; a seeded
+ * generator gives varied-looking data that is identical on every run and on every
+ * machine.
+ */
+export type SeededRng = {
+    /** The next value in `[0, 1)`. */
+    next: () => number;
+    /**
+     * An integer in `[min, max]`, both inclusive. Bounds are trusted: `max` below
+     * `min` returns a value outside either, unchecked.
+     */
+    int: (min: number, max: number) => number;
+    /** One element. Throws on an empty list. */
+    pick: <T>(items: readonly T[]) => T;
+    /** A shuffled copy; the input is left alone. */
+    shuffle: <T>(items: readonly T[]) => T[];
+    /** Rewinds to the seed. Pass this to `setupMocks({ onReset })`. */
+    reset: () => void;
+};
+/**
+ * A mulberry32 generator — 32 bits of state, a handful of integer ops, no
+ * dependency. Its statistical quality is irrelevant here; reproducibility and
+ * being cheap enough to call inside a request handler are the requirements.
+ */
+export declare function createSeededRng(seed: number): SeededRng;

package/dist/seeded-rng.js

@@ -0,0 +1,52 @@
+/**
+ * Deterministic randomness for generated fixtures. `Math.random` in a mock makes
+ * a failing test unreproducible and a visual snapshot unstable; a seeded
+ * generator gives varied-looking data that is identical on every run and on every
+ * machine.
+ */
+/**
+ * A mulberry32 generator — 32 bits of state, a handful of integer ops, no
+ * dependency. Its statistical quality is irrelevant here; reproducibility and
+ * being cheap enough to call inside a request handler are the requirements.
+ */
+export function createSeededRng(seed) {
+    let state = seed >>> 0;
+    const next = () => {
+        state = (state + 0x6d2b79f5) >>> 0;
+        let t = state;
+        t = Math.imul(t ^ (t >>> 15), t | 1);
+        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+        return ((t ^ (t >>> 14)) >>> 0) / 4_294_967_296;
+    };
+    const int = (min, max) => min + Math.floor(next() * (max - min + 1));
+    return {
+        next,
+        int,
+        pick: (items) => {
+            // Guard on length, not on the read being `undefined`: `T` may itself
+            // include `undefined`, and `pick([undefined, 1])` must return the element
+            // rather than report an empty list.
+            if (items.length === 0) {
+                throw new Error('http-client-msw: cannot pick from an empty list');
+            }
+            return items[int(0, items.length - 1)];
+        },
+        shuffle: (items) => {
+            const shuffled = [...items];
+            for (let i = shuffled.length - 1; i > 0; i--) {
+                const j = int(0, i);
+                // Both indices are in range by the loop bound, so the swap is
+                // unconditional — skipping it on an `undefined` *element* would let the
+                // result depend on the values while still consuming the draw above,
+                // which is exactly the reproducibility this generator exists to give.
+                const a = shuffled[i];
+                shuffled[i] = shuffled[j];
+                shuffled[j] = a;
+            }
+            return shuffled;
+        },
+        reset: () => {
+            state = seed >>> 0;
+        },
+    };
+}

package/dist/setup.d.ts

@@ -0,0 +1,54 @@
+import type { RequestHandler, WebSocketHandler } from 'msw';
+/**
+ * Anything msw accepts as a handler. Typed handlers from `createMockApi` are
+ * `RequestHandler`s; the union leaves room for a websocket mock in the same
+ * array without a second setup path.
+ */
+export type MockSetupHandler = RequestHandler | WebSocketHandler;
+/**
+ * A callback that returns mock state to its seeded starting point. Stores built
+ * with `createMockStore` expose exactly this as `store.reset`.
+ */
+export type MockResetCallback = () => void;
+export type MockSetupOptions = {
+    /**
+     * Callbacks that restore mock state, run **in declaration order** by `reset()`
+     * on whichever entry serves these handlers. This is how a stateful mock stops
+     * leaking writes from one test into the next: the handlers close over a store,
+     * and the store's `reset` is declared here once rather than at every call site.
+     *
+     * Order matters when one reset feeds another. A store whose seed function draws
+     * from a seeded rng must be listed *after* that rng, or each reset re-seeds
+     * from wherever the previous one left the sequence.
+     */
+    onReset?: readonly MockResetCallback[];
+};
+/**
+ * An environment-neutral description of a mock deployment: the handler array
+ * plus the state resets that belong with it. It holds no msw setup object of its
+ * own, which is what lets the same value be handed to the browser entry
+ * (`setupWorker`) or the node entry (`setupServer`) without either environment's
+ * msw import reaching the other's bundle.
+ */
+export type MockSetup = {
+    handlers: readonly MockSetupHandler[];
+    /** Runs every `onReset` callback in declaration order. */
+    resetState: () => void;
+};
+/**
+ * Bundles handlers with their state resets.
+ *
+ * ```ts
+ * const rng = createSeededRng(42);
+ * const things = createMockStore(() => [
+ *   { id: 't1', name: 'First', size: rng.int(1, 100) },
+ * ]);
+ *
+ * export const mocks = setupMocks(
+ *   [mock.get('/things', ({ response }) => response(200).json(things.list()))],
+ *   // The rng first: the store's seed draws from it.
+ *   { onReset: [rng.reset, things.reset] },
+ * );
+ * ```
+ */
+export declare function setupMocks(handlers: readonly MockSetupHandler[], options?: MockSetupOptions): MockSetup;

package/dist/setup.js

@@ -0,0 +1,26 @@
+/**
+ * Bundles handlers with their state resets.
+ *
+ * ```ts
+ * const rng = createSeededRng(42);
+ * const things = createMockStore(() => [
+ *   { id: 't1', name: 'First', size: rng.int(1, 100) },
+ * ]);
+ *
+ * export const mocks = setupMocks(
+ *   [mock.get('/things', ({ response }) => response(200).json(things.list()))],
+ *   // The rng first: the store's seed draws from it.
+ *   { onReset: [rng.reset, things.reset] },
+ * );
+ * ```
+ */
+export function setupMocks(handlers, options = {}) {
+    const onReset = options.onReset ?? [];
+    return {
+        handlers,
+        resetState: () => {
+            for (const reset of onReset)
+                reset();
+        },
+    };
+}

package/dist/worker-options.d.ts

@@ -0,0 +1,55 @@
+import type { StartOptions } from 'msw/browser';
+/**
+ * The browser entry's decisions, factored out of `browser.ts` so they are
+ * testable without a service worker: a vitest run cannot register one, but it
+ * can assert the options that would be passed and the start-once behaviour.
+ */
+export type MockWorkerOptions = {
+    /**
+     * The app's **public base path** — `import.meta.env.BASE_URL` under Vite — used
+     * to locate the worker script for a subpath deployment. This is not the API
+     * base from `createMockApi`: the script is served by the app, the API is
+     * whatever the app talks to.
+     *
+     * @default '/'
+     */
+    baseUrl?: string;
+    /**
+     * What msw does with a request no handler matched.
+     *
+     * Defaults to `'bypass'`, unlike msw's own `'warn'`: an app running against
+     * mocks still loads its own documents, modules, images, and fonts, and warning
+     * on every one of them buries the requests a developer is actually looking at.
+     * Use `'warn'` while filling gaps in a mock set.
+     */
+    onUnhandledRequest?: StartOptions['onUnhandledRequest'];
+    /**
+     * Suppress msw's per-request console logging. Defaults to `true` — the request
+     * log is long enough to hide application logs, and the network panel already
+     * shows the same traffic.
+     */
+    quiet?: boolean;
+    /** Escape hatch merged last into msw's own `worker.start()` options. */
+    start?: StartOptions;
+};
+export declare function buildWorkerStartOptions(options?: MockWorkerOptions): StartOptions;
+export type IdempotentStart = {
+    /** Runs the wrapped function at most once, until `invalidate()`. */
+    start: () => Promise<void>;
+    /**
+     * Forgets a completed start so the next `start()` runs again. Whatever the
+     * start registered has to be torn down first — a memo pointing at a stopped
+     * worker resolves immediately and intercepts nothing.
+     */
+    invalidate: () => void;
+};
+/**
+ * Wraps a start function so concurrent and repeated calls share one
+ * registration. An app entry, a hot reload, and a Playwright fixture can all
+ * call `start()`; registering the worker again mid-session would reset its
+ * handler list and drop any runtime overrides a test had installed.
+ *
+ * A rejected start invalidates itself, so a caller can retry after fixing
+ * whatever failed (a missing `mockServiceWorker.js`, most often).
+ */
+export declare function createIdempotentStart(start: () => Promise<void>): IdempotentStart;

package/dist/worker-options.js

@@ -0,0 +1,49 @@
+import { resolveWorkerScriptUrl } from './base-url.js';
+export function buildWorkerStartOptions(options = {}) {
+    const { baseUrl, onUnhandledRequest, quiet, start } = options;
+    return {
+        ...start,
+        // Resolved after the spread rather than defaulted before it: an options
+        // object forwarded with explicit `undefined` values would otherwise put
+        // those keys back and hand msw its own defaults instead of ours. `start`
+        // still wins over the named options where it sets a value.
+        onUnhandledRequest: start?.onUnhandledRequest ?? onUnhandledRequest ?? 'bypass',
+        quiet: start?.quiet ?? quiet ?? true,
+        serviceWorker: {
+            ...start?.serviceWorker,
+            // The same hole one level down: a `serviceWorker` object populated from
+            // another options bag carries an explicit `url: undefined`, which spread
+            // over the resolved path would erase it and send msw to its own default
+            // location — the wrong one for a subpath deployment.
+            url: start?.serviceWorker?.url ?? resolveWorkerScriptUrl(baseUrl),
+        },
+    };
+}
+/**
+ * Wraps a start function so concurrent and repeated calls share one
+ * registration. An app entry, a hot reload, and a Playwright fixture can all
+ * call `start()`; registering the worker again mid-session would reset its
+ * handler list and drop any runtime overrides a test had installed.
+ *
+ * A rejected start invalidates itself, so a caller can retry after fixing
+ * whatever failed (a missing `mockServiceWorker.js`, most often).
+ */
+export function createIdempotentStart(start) {
+    let pending;
+    const invalidate = () => {
+        pending = undefined;
+    };
+    return {
+        start: () => {
+            // Called through an async wrapper so a synchronous throw from `start`
+            // rejects the returned promise instead of escaping as an exception the
+            // caller has no way to `.catch`.
+            pending ??= (async () => await start())().catch((error) => {
+                invalidate();
+                throw error;
+            });
+            return pending;
+        },
+        invalidate,
+    };
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@r0hitsharma/http-client-msw",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "src"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "default": "./dist/browser.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "default": "./dist/node.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "clean": "rm -rf dist",
+    "prepare": "npm run build",
+    "type:check": "tsc -p tsconfig.json --noEmit",
+    "lint": "oxlint -c oxlint.config.ts --max-warnings=0 src",
+    "lint:fix": "oxlint -c oxlint.config.ts --fix src",
+    "format": "oxfmt -c oxfmt.config.ts --write src",
+    "format:check": "oxfmt -c oxfmt.config.ts --check src",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "openapi-msw": "2.0.0"
+  },
+  "peerDependencies": {
+    "msw": "^2.10.5"
+  },
+  "devDependencies": {
+    "@r0hitsharma/oxfmt-config": "*",
+    "@r0hitsharma/oxlint-config": "*",
+    "@r0hitsharma/tsconfig": "*",
+    "@types/node": "24.13.3",
+    "msw": "2.15.0",
+    "oxfmt": "0.67.0",
+    "oxlint": "1.82.0",
+    "vitest": "^4.1.9"
+  },
+  "version": "0.12.0-rohit-fork-ci.1",
+  "repository": {
+    "url": "https://github.com/r0hitsharma/uikit"
+  }
+}