@farming-labs/theme 0.0.24 → 0.0.25

package/dist/node_modules/.pnpm/@vitest_spy@3.2.4/node_modules/@vitest/spy/dist/index.mjs

@@ -0,0 +1,171 @@
+import { M, T } from "../../../../../tinyspy@4.0.4/node_modules/tinyspy/dist/index.mjs";
+
+//#region ../../node_modules/.pnpm/@vitest+spy@3.2.4/node_modules/@vitest/spy/dist/index.js
+const mocks = /* @__PURE__ */ new Set();
+function isMockFunction(fn) {
+	return typeof fn === "function" && "_isMockFunction" in fn && fn._isMockFunction;
+}
+function spyOn(obj, method, accessType) {
+	const objMethod = accessType ? { [{
+		get: "getter",
+		set: "setter"
+	}[accessType]]: method } : method;
+	let state;
+	const descriptor = getDescriptor(obj, method);
+	const fn = descriptor && descriptor[accessType || "value"];
+	if (isMockFunction(fn)) state = fn.mock._state();
+	try {
+		const spy = enhanceSpy(M(obj, objMethod));
+		if (state) spy.mock._state(state);
+		return spy;
+	} catch (error) {
+		if (error instanceof TypeError && Symbol.toStringTag && obj[Symbol.toStringTag] === "Module" && (error.message.includes("Cannot redefine property") || error.message.includes("Cannot replace module namespace") || error.message.includes("can't redefine non-configurable property"))) throw new TypeError(`Cannot spy on export "${String(objMethod)}". Module namespace is not configurable in ESM. See: https://vitest.dev/guide/browser/#limitations`, { cause: error });
+		throw error;
+	}
+}
+let callOrder = 0;
+function enhanceSpy(spy) {
+	const stub = spy;
+	let implementation;
+	let onceImplementations = [];
+	let implementationChangedTemporarily = false;
+	let instances = [];
+	let contexts = [];
+	let invocations = [];
+	const state = T(spy);
+	const mockContext = {
+		get calls() {
+			return state.calls;
+		},
+		get contexts() {
+			return contexts;
+		},
+		get instances() {
+			return instances;
+		},
+		get invocationCallOrder() {
+			return invocations;
+		},
+		get results() {
+			return state.results.map(([callType, value]) => {
+				return {
+					type: callType === "error" ? "throw" : "return",
+					value
+				};
+			});
+		},
+		get settledResults() {
+			return state.resolves.map(([callType, value]) => {
+				return {
+					type: callType === "error" ? "rejected" : "fulfilled",
+					value
+				};
+			});
+		},
+		get lastCall() {
+			return state.calls[state.calls.length - 1];
+		},
+		_state(state) {
+			if (state) {
+				implementation = state.implementation;
+				onceImplementations = state.onceImplementations;
+				implementationChangedTemporarily = state.implementationChangedTemporarily;
+			}
+			return {
+				implementation,
+				onceImplementations,
+				implementationChangedTemporarily
+			};
+		}
+	};
+	function mockCall(...args) {
+		instances.push(this);
+		contexts.push(this);
+		invocations.push(++callOrder);
+		return (implementationChangedTemporarily ? implementation : onceImplementations.shift() || implementation || state.getOriginal() || (() => {})).apply(this, args);
+	}
+	let name = stub.name;
+	stub.getMockName = () => name || "vi.fn()";
+	stub.mockName = (n) => {
+		name = n;
+		return stub;
+	};
+	stub.mockClear = () => {
+		state.reset();
+		instances = [];
+		contexts = [];
+		invocations = [];
+		return stub;
+	};
+	stub.mockReset = () => {
+		stub.mockClear();
+		implementation = void 0;
+		onceImplementations = [];
+		return stub;
+	};
+	stub.mockRestore = () => {
+		stub.mockReset();
+		state.restore();
+		return stub;
+	};
+	if (Symbol.dispose) stub[Symbol.dispose] = () => stub.mockRestore();
+	stub.getMockImplementation = () => implementationChangedTemporarily ? implementation : onceImplementations.at(0) || implementation;
+	stub.mockImplementation = (fn) => {
+		implementation = fn;
+		state.willCall(mockCall);
+		return stub;
+	};
+	stub.mockImplementationOnce = (fn) => {
+		onceImplementations.push(fn);
+		return stub;
+	};
+	function withImplementation(fn, cb) {
+		const originalImplementation = implementation;
+		implementation = fn;
+		state.willCall(mockCall);
+		implementationChangedTemporarily = true;
+		const reset = () => {
+			implementation = originalImplementation;
+			implementationChangedTemporarily = false;
+		};
+		const result = cb();
+		if (typeof result === "object" && result && typeof result.then === "function") return result.then(() => {
+			reset();
+			return stub;
+		});
+		reset();
+		return stub;
+	}
+	stub.withImplementation = withImplementation;
+	stub.mockReturnThis = () => stub.mockImplementation(function() {
+		return this;
+	});
+	stub.mockReturnValue = (val) => stub.mockImplementation(() => val);
+	stub.mockReturnValueOnce = (val) => stub.mockImplementationOnce(() => val);
+	stub.mockResolvedValue = (val) => stub.mockImplementation(() => Promise.resolve(val));
+	stub.mockResolvedValueOnce = (val) => stub.mockImplementationOnce(() => Promise.resolve(val));
+	stub.mockRejectedValue = (val) => stub.mockImplementation(() => Promise.reject(val));
+	stub.mockRejectedValueOnce = (val) => stub.mockImplementationOnce(() => Promise.reject(val));
+	Object.defineProperty(stub, "mock", { get: () => mockContext });
+	state.willCall(mockCall);
+	mocks.add(stub);
+	return stub;
+}
+function fn(implementation) {
+	const enhancedSpy = enhanceSpy(M({ spy: implementation || function() {} }, "spy"));
+	if (implementation) enhancedSpy.mockImplementation(implementation);
+	return enhancedSpy;
+}
+function getDescriptor(obj, method) {
+	const objDescriptor = Object.getOwnPropertyDescriptor(obj, method);
+	if (objDescriptor) return objDescriptor;
+	let currentProto = Object.getPrototypeOf(obj);
+	while (currentProto !== null) {
+		const descriptor = Object.getOwnPropertyDescriptor(currentProto, method);
+		if (descriptor) return descriptor;
+		currentProto = Object.getPrototypeOf(currentProto);
+	}
+}
+
+//#endregion
+export { fn, isMockFunction, mocks, spyOn };

package/dist/node_modules/.pnpm/@vitest_utils@3.2.4/node_modules/@vitest/utils/dist/chunk-_commonjsHelpers.mjs

@@ -0,0 +1,124 @@
+import { format as format$1, plugins } from "../../../../../@vitest_pretty-format@3.2.4/node_modules/@vitest/pretty-format/dist/index.mjs";
+import inspect$1 from "../../../../../loupe@3.2.1/node_modules/loupe/lib/index.mjs";
+
+//#region ../../node_modules/.pnpm/@vitest+utils@3.2.4/node_modules/@vitest/utils/dist/chunk-_commonjsHelpers.js
+const { AsymmetricMatcher, DOMCollection, DOMElement, Immutable, ReactElement, ReactTestComponent } = plugins;
+const PLUGINS = [
+	ReactTestComponent,
+	ReactElement,
+	DOMElement,
+	DOMCollection,
+	Immutable,
+	AsymmetricMatcher
+];
+function stringify(object, maxDepth = 10, { maxLength, ...options } = {}) {
+	const MAX_LENGTH = maxLength ?? 1e4;
+	let result;
+	try {
+		result = format$1(object, {
+			maxDepth,
+			escapeString: false,
+			plugins: PLUGINS,
+			...options
+		});
+	} catch {
+		result = format$1(object, {
+			callToJSON: false,
+			maxDepth,
+			escapeString: false,
+			plugins: PLUGINS,
+			...options
+		});
+	}
+	return result.length >= MAX_LENGTH && maxDepth > 1 ? stringify(object, Math.floor(Math.min(maxDepth, Number.MAX_SAFE_INTEGER) / 2), {
+		maxLength,
+		...options
+	}) : result;
+}
+const formatRegExp = /%[sdjifoOc%]/g;
+function format(...args) {
+	if (typeof args[0] !== "string") {
+		const objects = [];
+		for (let i = 0; i < args.length; i++) objects.push(inspect(args[i], {
+			depth: 0,
+			colors: false
+		}));
+		return objects.join(" ");
+	}
+	const len = args.length;
+	let i = 1;
+	const template = args[0];
+	let str = String(template).replace(formatRegExp, (x) => {
+		if (x === "%%") return "%";
+		if (i >= len) return x;
+		switch (x) {
+			case "%s": {
+				const value = args[i++];
+				if (typeof value === "bigint") return `${value.toString()}n`;
+				if (typeof value === "number" && value === 0 && 1 / value < 0) return "-0";
+				if (typeof value === "object" && value !== null) {
+					if (typeof value.toString === "function" && value.toString !== Object.prototype.toString) return value.toString();
+					return inspect(value, {
+						depth: 0,
+						colors: false
+					});
+				}
+				return String(value);
+			}
+			case "%d": {
+				const value = args[i++];
+				if (typeof value === "bigint") return `${value.toString()}n`;
+				return Number(value).toString();
+			}
+			case "%i": {
+				const value = args[i++];
+				if (typeof value === "bigint") return `${value.toString()}n`;
+				return Number.parseInt(String(value)).toString();
+			}
+			case "%f": return Number.parseFloat(String(args[i++])).toString();
+			case "%o": return inspect(args[i++], {
+				showHidden: true,
+				showProxy: true
+			});
+			case "%O": return inspect(args[i++]);
+			case "%c":
+				i++;
+				return "";
+			case "%j": try {
+				return JSON.stringify(args[i++]);
+			} catch (err) {
+				const m = err.message;
+				if (m.includes("circular structure") || m.includes("cyclic structures") || m.includes("cyclic object")) return "[Circular]";
+				throw err;
+			}
+			default: return x;
+		}
+	});
+	for (let x = args[i]; i < len; x = args[++i]) if (x === null || typeof x !== "object") str += ` ${x}`;
+	else str += ` ${inspect(x)}`;
+	return str;
+}
+function inspect(obj, options = {}) {
+	if (options.truncate === 0) options.truncate = Number.POSITIVE_INFINITY;
+	return inspect$1(obj, options);
+}
+function objDisplay(obj, options = {}) {
+	if (typeof options.truncate === "undefined") options.truncate = 40;
+	const str = inspect(obj, options);
+	const type = Object.prototype.toString.call(obj);
+	if (options.truncate && str.length >= options.truncate) if (type === "[object Function]") {
+		const fn = obj;
+		return !fn.name ? "[Function]" : `[Function: ${fn.name}]`;
+	} else if (type === "[object Array]") return `[ Array(${obj.length}) ]`;
+	else if (type === "[object Object]") {
+		const keys = Object.keys(obj);
+		return `{ Object (${keys.length > 2 ? `${keys.splice(0, 2).join(", ")}, ...` : keys.join(", ")}) }`;
+	} else return str;
+	return str;
+}
+function getDefaultExportFromCjs(x) {
+	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
+
+//#endregion
+export { format, getDefaultExportFromCjs, inspect, objDisplay, stringify };