@storybook/test 8.2.0-alpha.9 → 8.2.0-beta.1

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 import { AsymmetricMatchersContaining, MatchersObject, MatcherState, JestAssertion, ExpectStatic } from '@vitest/expect';
 import { TestingLibraryMatchers } from '@testing-library/jest-dom/matchers';
+import * as domTestingLibrary from '@testing-library/dom';
+import _userEvent from '@testing-library/user-event';
 import { spyOn as spyOn$1, fn as fn$1, MaybeMocked, MaybeMockedDeep, MaybePartiallyMocked, MaybePartiallyMockedDeep, MockInstance } from '@vitest/spy';
 export * from '@vitest/spy';
 export { isMockFunction, mocks } from '@vitest/spy';
-import * as domTestingLibrary from '@testing-library/dom';
-import _userEvent from '@testing-library/user-event';
 
 type Promisify<Fn> = Fn extends (...args: infer A) => infer R ? (...args: A) => R extends Promise<any> ? R : Promise<R> : Fn;
 type PromisifyObject<O> = {
@@ -33,56 +33,6 @@ interface Expect extends AsymmetricMatchersContaining {
     not: AsymmetricMatchersContaining;
 }
 
-type Listener = (mock: MockInstance, args: unknown[]) => void;
-declare function onMockCall(callback: Listener): () => void;
-declare const spyOn: typeof spyOn$1;
-declare const fn: typeof fn$1;
-/**
- * Calls [`.mockClear()`](https://vitest.dev/api/mock#mockclear) on every mocked function. This will only empty `.mock` state, it will not reset implementation.
- *
- * It is useful if you need to clean up mock between different assertions.
- */
-declare function clearAllMocks(): void;
-/**
- * Calls [`.mockReset()`](https://vitest.dev/api/mock#mockreset) on every mocked function. This will empty `.mock` state, reset "once" implementations and force the base implementation to return `undefined` when invoked.
- *
- * This is useful when you want to completely reset a mock to the default state.
- */
-declare function resetAllMocks(): void;
-/**
- * Calls [`.mockRestore()`](https://vitest.dev/api/mock#mockrestore) on every mocked function. This will restore all original implementations.
- */
-declare function restoreAllMocks(): void;
-/**
- * Type helper for TypeScript. Just returns the object that was passed.
- *
- * When `partial` is `true` it will expect a `Partial<T>` as a return value. By default, this will only make TypeScript believe that
- * the first level values are mocked. You can pass down `{ deep: true }` as a second argument to tell TypeScript that the whole object is mocked, if it actually is.
- *
- * @param item Anything that can be mocked
- * @param deep If the object is deeply mocked
- * @param options If the object is partially or deeply mocked
- */
-declare function mocked<T>(item: T, deep?: false): MaybeMocked<T>;
-declare function mocked<T>(item: T, deep: true): MaybeMockedDeep<T>;
-declare function mocked<T>(item: T, options: {
-    partial?: false;
-    deep?: false;
-}): MaybeMocked<T>;
-declare function mocked<T>(item: T, options: {
-    partial?: false;
-    deep: true;
-}): MaybeMockedDeep<T>;
-declare function mocked<T>(item: T, options: {
-    partial: true;
-    deep?: false;
-}): MaybePartiallyMocked<T>;
-declare function mocked<T>(item: T, options: {
-    partial: true;
-    deep: true;
-}): MaybePartiallyMockedDeep<T>;
-declare function mocked<T>(item: T): MaybeMocked<T>;
-
 declare const buildQueries: typeof domTestingLibrary.buildQueries;
 declare const configure: typeof domTestingLibrary.configure;
 declare const createEvent: domTestingLibrary.CreateObject & domTestingLibrary.CreateFunction;
@@ -160,6 +110,63 @@ interface UserEvent extends _UserEvent {
 }
 declare const userEvent: UserEvent;
 
+type Listener = (mock: MockInstance, args: unknown[]) => void;
+declare function onMockCall(callback: Listener): () => void;
+declare const spyOn: typeof spyOn$1;
+declare const fn: typeof fn$1;
+/**
+ * Calls [`.mockClear()`](https://vitest.dev/api/mock#mockclear) on every mocked function. This will only empty `.mock` state, it will not reset implementation.
+ *
+ * It is useful if you need to clean up mock between different assertions.
+ */
+declare function clearAllMocks(): void;
+/**
+ * Calls [`.mockReset()`](https://vitest.dev/api/mock#mockreset) on every mocked function. This will empty `.mock` state, reset "once" implementations and force the base implementation to return `undefined` when invoked.
+ *
+ * This is useful when you want to completely reset a mock to the default state.
+ */
+declare function resetAllMocks(): void;
+/**
+ * Calls [`.mockRestore()`](https://vitest.dev/api/mock#mockrestore) on every mocked function. This will restore all original implementations.
+ */
+declare function restoreAllMocks(): void;
+/**
+ * Type helper for TypeScript. Just returns the object that was passed.
+ *
+ * When `partial` is `true` it will expect a `Partial<T>` as a return value. By default, this will only make TypeScript believe that
+ * the first level values are mocked. You can pass down `{ deep: true }` as a second argument to tell TypeScript that the whole object is mocked, if it actually is.
+ *
+ * @param item Anything that can be mocked
+ * @param deep If the object is deeply mocked
+ * @param options If the object is partially or deeply mocked
+ */
+declare function mocked<T>(item: T, deep?: false): MaybeMocked<T>;
+declare function mocked<T>(item: T, deep: true): MaybeMockedDeep<T>;
+declare function mocked<T>(item: T, options: {
+    partial?: false;
+    deep?: false;
+}): MaybeMocked<T>;
+declare function mocked<T>(item: T, options: {
+    partial?: false;
+    deep: true;
+}): MaybeMockedDeep<T>;
+declare function mocked<T>(item: T, options: {
+    partial: true;
+    deep?: false;
+}): MaybePartiallyMocked<T>;
+declare function mocked<T>(item: T, options: {
+    partial: true;
+    deep: true;
+}): MaybePartiallyMockedDeep<T>;
+declare function mocked<T>(item: T): MaybeMocked<T>;
+
+type Queries = ReturnType<typeof within<typeof queries>>;
+declare module '@storybook/csf' {
+    interface Canvas extends Queries {
+    }
+    interface StoryContext {
+    }
+}
 declare const expect: Expect;
 
 declare const traverseArgs: (value: unknown, depth?: number, key?: string) => unknown;