@aussieljk/forkbook 0.0.0-stage → 0.0.1-1

package/dist/preview/_chunks/runtime-DuHdxMFA.js

@@ -0,0 +1,387 @@
+import { n as __esmMin, r as __exportAll } from "./runtime-BdGkqNEt.js";
+import { H as init_dist, V as T, lt as dedent, ut as init_esm } from "./runtime-BZSnICCg.js";
+import { Et as once, _ as instrument, g as init_instrumenter, r as definePreviewAddon, wt as init_client_logger } from "./runtime-DrTjJkPY.js";
+import { a as customMatchers, c as setState, d as isMockFunction, f as mocks, i as JestExtend, l as fn$1, n as JestAsymmetricMatchers, o as getState, p as spyOn$1, r as JestChaiExpect, s as init_dist$1, t as GLOBAL_EXPECT, u as init_dist$2 } from "./runtime-q3wt0e_N.js";
+import { a as Assertion, c as init_chai, l as use, o as assert, s as expect$2, u as utils_exports } from "./runtime-BIzIdDbb.js";
+import { a as matchers_exports, i as init_matchers, r as userEvent$1, t as init_esm$1 } from "./runtime-CqHxptiK.js";
+import { r as init_dom_esm, t as dom_esm_exports } from "./runtime-DZToXfvO.js";
+//#region src/test/expect.ts
+function createExpect() {
+	use(JestExtend);
+	use(JestChaiExpect);
+	use(JestAsymmetricMatchers);
+	const expect = ((value, message) => {
+		const { assertionCalls } = getState(expect);
+		setState({
+			assertionCalls: assertionCalls + 1,
+			soft: false
+		}, expect);
+		return expect$2(value, message);
+	});
+	Object.assign(expect, expect$2);
+	expect.getState = () => getState(expect);
+	expect.setState = (state) => setState(state, expect);
+	expect.extend = (expects) => expect$2.extend(expect, expects);
+	expect.soft = (...args) => {
+		const assert = expect(...args);
+		expect.setState({ soft: true });
+		return assert;
+	};
+	expect.extend(customMatchers);
+	expect.unreachable = (message) => {
+		assert.fail(`expected${message ? ` "${message}" ` : " "}not to be reached`);
+	};
+	function assertions(expected) {
+		const errorGen = () => /* @__PURE__ */ new Error(`expected number of assertions to be ${expected}, but got ${expect.getState().assertionCalls}`);
+		if ("captureStackTrace" in Error && typeof Error.captureStackTrace === "function") Error.captureStackTrace(errorGen(), assertions);
+		expect.setState({
+			expectedAssertionsNumber: expected,
+			expectedAssertionsNumberErrorGen: errorGen
+		});
+	}
+	function hasAssertions() {
+		const error = /* @__PURE__ */ new Error("expected any number of assertion, but got none");
+		if ("captureStackTrace" in Error && typeof Error.captureStackTrace === "function") Error.captureStackTrace(error, hasAssertions);
+		expect.setState({
+			isExpectingAssertions: true,
+			isExpectingAssertionsError: error
+		});
+	}
+	setState({
+		assertionCalls: 0,
+		isExpectingAssertions: false,
+		isExpectingAssertionsError: null,
+		expectedAssertionsNumber: null,
+		expectedAssertionsNumberErrorGen: null
+	}, expect);
+	utils_exports.addMethod(expect, "assertions", assertions);
+	utils_exports.addMethod(expect, "hasAssertions", hasAssertions);
+	expect.extend(matchers_exports);
+	return expect;
+}
+var expect$1;
+function init_expect() {
+	return (init_expect = __esmMin((() => {
+		init_matchers();
+		init_dist$1();
+		init_chai();
+		expect$1 = createExpect();
+		// @vitest/expect expects this to be set
+		Object.defineProperty(globalThis, GLOBAL_EXPECT, {
+			value: expect$1,
+			writable: true,
+			configurable: true
+		});
+	})))();
+}
+//#endregion
+//#region src/test/spy.ts
+function onMockCall(callback) {
+	listeners.add(callback);
+	return () => void listeners.delete(callback);
+}
+function fn(implementation) {
+	return reactiveMock(implementation ? fn$1(implementation) : fn$1());
+}
+function reactiveMock(mock) {
+	const reactive = listenWhenCalled(mock);
+	const originalMockImplementation = reactive.mockImplementation.bind(null);
+	reactive.mockImplementation = (fn) => listenWhenCalled(originalMockImplementation(fn));
+	return reactive;
+}
+function listenWhenCalled(mock) {
+	const state = T(mock);
+	const impl = state.impl;
+	state.willCall(function(...args) {
+		listeners.forEach((listener) => listener(mock, args));
+		return impl?.apply(this, args);
+	});
+	return mock;
+}
+/**
+* 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.
+*/
+function clearAllMocks() {
+	mocks.forEach((spy) => spy.mockClear());
+	moduleMockSpies.forEach((spy) => spy.mockClear());
+}
+/**
+* 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.
+*/
+function resetAllMocks() {
+	mocks.forEach((spy) => spy.mockReset());
+	moduleMockSpies.forEach((spy) => spy.mockReset());
+}
+/**
+* Calls [`.mockRestore()`](https://vitest.dev/api/mock#mockrestore) on every mocked function. This
+* will restore all original implementations.
+*/
+function restoreAllMocks() {
+	mocks.forEach((spy) => spy.mockRestore());
+	moduleMockSpies.forEach((spy) => spy.mockClear());
+}
+function mocked(item, _options = {}) {
+	return item;
+}
+var moduleMockSpies, listeners, spyOn;
+function init_spy() {
+	return (init_spy = __esmMin((() => {
+		init_dist$2();
+		init_dist();
+		moduleMockSpies = globalThis.__STORYBOOK_MODULE_MOCK_SPIES__ ??= /* @__PURE__ */ new Set();
+		listeners = /* @__PURE__ */ new Set();
+		spyOn = ((...args) => {
+			return reactiveMock(spyOn$1(...args));
+		});
+	})))();
+}
+//#endregion
+//#region src/test/testing-library.ts
+var testingLibrary, buildQueries, configure, createEvent, fireEvent, findAllByAltText, findAllByDisplayValue, findAllByLabelText, findAllByPlaceholderText, findAllByRole, findAllByTestId, findAllByText, findAllByTitle, findByAltText, findByDisplayValue, findByLabelText, findByPlaceholderText, findByRole, findByTestId, findByText, findByTitle, getAllByAltText, getAllByDisplayValue, getAllByLabelText, getAllByPlaceholderText, getAllByRole, getAllByTestId, getAllByText, getAllByTitle, getByAltText, getByDisplayValue, getByLabelText, getByPlaceholderText, getByRole, getByTestId, getByText, getByTitle, getConfig, getDefaultNormalizer, getElementError, getNodeText, getQueriesForElement, getRoles, getSuggestedQuery, isInaccessible, logDOM, logRoles, prettyDOM, queries, queryAllByAltText, queryAllByAttribute, queryAllByDisplayValue, queryAllByLabelText, queryAllByPlaceholderText, queryAllByRole, queryAllByTestId, queryAllByText, queryAllByTitle, queryByAltText, queryByAttribute, queryByDisplayValue, queryByLabelText, queryByPlaceholderText, queryByRole, queryByTestId, queryByText, queryByTitle, queryHelpers, screen, waitFor, waitForElementToBeRemoved, within, prettyFormat, uninstrumentedUserEvent, userEvent;
+function init_testing_library() {
+	return (init_testing_library = __esmMin((() => {
+		init_dom_esm();
+		init_esm$1();
+		init_client_logger();
+		init_instrumenter();
+		init_esm();
+		testingLibrary = instrument({ ...dom_esm_exports }, {
+			getKeys: (obj) => Object.keys(obj).filter((key) => key !== "eventWrapper"),
+			intercept: (method, path) => path[0] === "fireEvent" || method.startsWith("find") || method.startsWith("waitFor")
+		});
+		testingLibrary.screen = new Proxy(testingLibrary.screen, { get(target, prop, receiver) {
+			if (typeof window !== "undefined" && globalThis.location?.href?.includes("viewMode=docs")) once.warn(dedent`
+        You are using Testing Library's \`screen\` object while the story is rendered in docs mode. This will likely lead to issues, as multiple stories are rendered in the same page and therefore screen will potentially find multiple elements. Use the \`canvas\` utility from the story context instead, which will scope the queries to each story's canvas.
+
+        More info: https://storybook.js.org/docs/writing-tests/interaction-testing?ref=error#querying-the-canvas
+      `);
+			return Reflect.get(target, prop, receiver);
+		} });
+		({buildQueries, configure, createEvent, fireEvent, findAllByAltText, findAllByDisplayValue, findAllByLabelText, findAllByPlaceholderText, findAllByRole, findAllByTestId, findAllByText, findAllByTitle, findByAltText, findByDisplayValue, findByLabelText, findByPlaceholderText, findByRole, findByTestId, findByText, findByTitle, getAllByAltText, getAllByDisplayValue, getAllByLabelText, getAllByPlaceholderText, getAllByRole, getAllByTestId, getAllByText, getAllByTitle, getByAltText, getByDisplayValue, getByLabelText, getByPlaceholderText, getByRole, getByTestId, getByText, getByTitle, getConfig, getDefaultNormalizer, getElementError, getNodeText, getQueriesForElement, getRoles, getSuggestedQuery, isInaccessible, logDOM, logRoles, prettyDOM, queries, queryAllByAltText, queryAllByAttribute, queryAllByDisplayValue, queryAllByLabelText, queryAllByPlaceholderText, queryAllByRole, queryAllByTestId, queryAllByText, queryAllByTitle, queryByAltText, queryByAttribute, queryByDisplayValue, queryByLabelText, queryByPlaceholderText, queryByRole, queryByTestId, queryByText, queryByTitle, queryHelpers, screen, waitFor, waitForElementToBeRemoved, within, prettyFormat} = testingLibrary);
+		uninstrumentedUserEvent = userEvent$1;
+		({userEvent} = instrument({ userEvent: userEvent$1 }, {
+			intercept: true,
+			getKeys: (obj) => Object.keys(obj).filter((key) => key !== "eventWrapper")
+		}));
+	})))();
+}
+//#endregion
+//#region src/test/index.ts
+var test_exports = /* @__PURE__ */ __exportAll({
+	buildQueries: () => buildQueries,
+	clearAllMocks: () => clearAllMocks,
+	configure: () => configure,
+	createEvent: () => createEvent,
+	expect: () => expect,
+	findAllByAltText: () => findAllByAltText,
+	findAllByDisplayValue: () => findAllByDisplayValue,
+	findAllByLabelText: () => findAllByLabelText,
+	findAllByPlaceholderText: () => findAllByPlaceholderText,
+	findAllByRole: () => findAllByRole,
+	findAllByTestId: () => findAllByTestId,
+	findAllByText: () => findAllByText,
+	findAllByTitle: () => findAllByTitle,
+	findByAltText: () => findByAltText,
+	findByDisplayValue: () => findByDisplayValue,
+	findByLabelText: () => findByLabelText,
+	findByPlaceholderText: () => findByPlaceholderText,
+	findByRole: () => findByRole,
+	findByTestId: () => findByTestId,
+	findByText: () => findByText,
+	findByTitle: () => findByTitle,
+	fireEvent: () => fireEvent,
+	fn: () => fn,
+	getAllByAltText: () => getAllByAltText,
+	getAllByDisplayValue: () => getAllByDisplayValue,
+	getAllByLabelText: () => getAllByLabelText,
+	getAllByPlaceholderText: () => getAllByPlaceholderText,
+	getAllByRole: () => getAllByRole,
+	getAllByTestId: () => getAllByTestId,
+	getAllByText: () => getAllByText,
+	getAllByTitle: () => getAllByTitle,
+	getByAltText: () => getByAltText,
+	getByDisplayValue: () => getByDisplayValue,
+	getByLabelText: () => getByLabelText,
+	getByPlaceholderText: () => getByPlaceholderText,
+	getByRole: () => getByRole,
+	getByTestId: () => getByTestId,
+	getByText: () => getByText,
+	getByTitle: () => getByTitle,
+	getConfig: () => getConfig,
+	getDefaultNormalizer: () => getDefaultNormalizer,
+	getElementError: () => getElementError,
+	getNodeText: () => getNodeText,
+	getQueriesForElement: () => getQueriesForElement,
+	getRoles: () => getRoles,
+	getSuggestedQuery: () => getSuggestedQuery,
+	isInaccessible: () => isInaccessible,
+	isMockFunction: () => isMockFunction,
+	logDOM: () => logDOM,
+	logRoles: () => logRoles,
+	mocked: () => mocked,
+	mocks: () => mocks,
+	onMockCall: () => onMockCall,
+	prettyDOM: () => prettyDOM,
+	prettyFormat: () => prettyFormat,
+	queries: () => queries,
+	queryAllByAltText: () => queryAllByAltText,
+	queryAllByAttribute: () => queryAllByAttribute,
+	queryAllByDisplayValue: () => queryAllByDisplayValue,
+	queryAllByLabelText: () => queryAllByLabelText,
+	queryAllByPlaceholderText: () => queryAllByPlaceholderText,
+	queryAllByRole: () => queryAllByRole,
+	queryAllByTestId: () => queryAllByTestId,
+	queryAllByText: () => queryAllByText,
+	queryAllByTitle: () => queryAllByTitle,
+	queryByAltText: () => queryByAltText,
+	queryByAttribute: () => queryByAttribute,
+	queryByDisplayValue: () => queryByDisplayValue,
+	queryByLabelText: () => queryByLabelText,
+	queryByPlaceholderText: () => queryByPlaceholderText,
+	queryByRole: () => queryByRole,
+	queryByTestId: () => queryByTestId,
+	queryByText: () => queryByText,
+	queryByTitle: () => queryByTitle,
+	queryHelpers: () => queryHelpers,
+	resetAllMocks: () => resetAllMocks,
+	restoreAllMocks: () => restoreAllMocks,
+	sb: () => sb,
+	screen: () => screen,
+	spyOn: () => spyOn,
+	uninstrumentedUserEvent: () => uninstrumentedUserEvent,
+	userEvent: () => userEvent,
+	waitFor: () => waitFor,
+	waitForElementToBeRemoved: () => waitForElementToBeRemoved,
+	within: () => within
+});
+function getChaiAssertionKeys(obj, depth) {
+	return [...Object.keys(Object.getPrototypeOf(obj)).filter((key) => !chaiAssertionPrivateApi.includes(key)), ...["not"].slice(depth / 3)];
+}
+function getObjectKeys(obj) {
+	return Object.keys(obj).filter((key) => key !== "any");
+}
+function getKeys(obj, depth) {
+	if ("constructor" in obj && obj.constructor === Assertion) return getChaiAssertionKeys(obj, depth);
+	return getObjectKeys(obj);
+}
+var chaiAssertionPrivateApi, expect, sb;
+function init_test() {
+	return (init_test = __esmMin((() => {
+		init_instrumenter();
+		init_chai();
+		init_expect();
+		init_spy();
+		init_testing_library();
+		chaiAssertionPrivateApi = [
+			"assert",
+			"__methods",
+			"__flags",
+			"_obj"
+		];
+		({expect} = instrument({ expect: expect$1 }, {
+			getKeys,
+			mutate: true,
+			intercept: (method) => method !== "expect"
+		}));
+		sb = { mock: () => {} };
+	})))();
+}
+//#endregion
+//#region src/test/preview.ts
+var resetAllMocksLoader, traverseArgs, nameSpiesAndWrapActionsInSpies, patchedFocus, enhanceContext, preview_default;
+function init_preview() {
+	return (init_preview = __esmMin((() => {
+		init_instrumenter();
+		init_test();
+		resetAllMocksLoader = ({ parameters }) => {
+			if (parameters?.test?.mockReset === true) resetAllMocks();
+			else if (parameters?.test?.clearMocks === true) clearAllMocks();
+			else if (parameters?.test?.restoreMocks !== false) restoreAllMocks();
+		};
+		traverseArgs = (value, depth = 0, key) => {
+			if (depth > 5) return value;
+			if (value == null) return value;
+			if (isMockFunction(value)) {
+				if (key) value.mockName(key);
+				return value;
+			}
+			if (typeof value === "function" && "isAction" in value && value.isAction && !("implicit" in value && value.implicit)) {
+				const mock = fn(value);
+				if (key) mock.mockName(key);
+				return mock;
+			}
+			if (Array.isArray(value)) {
+				depth++;
+				for (let i = 0; i < value.length; i++) if (Object.getOwnPropertyDescriptor(value, i)?.writable) value[i] = traverseArgs(value[i], depth);
+				return value;
+			}
+			if (typeof value === "object" && value.constructor === Object) {
+				depth++;
+				for (const [k, v] of Object.entries(value)) if (Object.getOwnPropertyDescriptor(value, k)?.writable) value[k] = traverseArgs(v, depth, k);
+				return value;
+			}
+			return value;
+		};
+		nameSpiesAndWrapActionsInSpies = ({ initialArgs }) => {
+			traverseArgs(initialArgs);
+		};
+		patchedFocus = false;
+		enhanceContext = async (context) => {
+			if (globalThis.HTMLElement && context.canvasElement instanceof globalThis.HTMLElement) context.canvas = within(context.canvasElement);
+			try {
+				const clipboard = globalThis.window?.navigator?.clipboard;
+				if (clipboard) {
+					context.userEvent = instrument({ userEvent: uninstrumentedUserEvent.setup() }, {
+						intercept: true,
+						getKeys: (obj) => Object.keys(obj).filter((key) => key !== "eventWrapper")
+					}).userEvent;
+					Object.defineProperty(globalThis.window.navigator, "clipboard", {
+						get: () => clipboard,
+						configurable: true
+					});
+					if (!patchedFocus) {
+						const originalFocus = HTMLElement.prototype.focus;
+						let currentFocus = HTMLElement.prototype.focus;
+						const noopFocus = () => {};
+						const focusingElements = /* @__PURE__ */ new Set();
+						Object.defineProperties(HTMLElement.prototype, { focus: {
+							configurable: true,
+							set: (newFocus) => {
+								currentFocus = newFocus;
+							},
+							get() {
+								if (this === HTMLElement.prototype) return currentFocus;
+								let browsingContext;
+								try {
+									browsingContext = this.ownerDocument?.defaultView;
+								} catch {
+									return currentFocus;
+								}
+								if (!browsingContext) return noopFocus;
+								if (focusingElements.has(this)) return originalFocus;
+								focusingElements.add(this);
+								setTimeout(() => focusingElements.delete(this), 0);
+								return currentFocus;
+							}
+						} });
+						patchedFocus = true;
+					}
+				}
+			} catch {}
+		};
+		preview_default = () => definePreviewAddon({ loaders: [
+			resetAllMocksLoader,
+			nameSpiesAndWrapActionsInSpies,
+			enhanceContext
+		] });
+	})))();
+}
+//#endregion
+export { init_spy as a, test_exports as i, preview_default as n, onMockCall as o, init_test as r, init_preview as t };