var __CODE__ = (() => { var __create = Object.create; var __defProp = Object.defineProperty; var __getOwnPropDesc = Object.getOwnPropertyDescriptor; var __getOwnPropNames = Object.getOwnPropertyNames; var __getProtoOf = Object.getPrototypeOf; var __hasOwnProp = Object.prototype.hasOwnProperty; var __esm = (fn, res) => function __init() { return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res; }; var __commonJS = (cb, mod) => function __require() { return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; }; var __export = (target, all) => { for (var name in all) __defProp(target, name, { get: all[name], enumerable: true }); }; var __copyProps = (to, from, except, desc) => { if (from && typeof from === "object" || typeof from === "function") { for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); } return to; }; var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( // If the importer is in node compatibility mode or this is not an ESM // file that has been converted to a CommonJS file using a Babel- // compatible transform (i.e. "__esModule" has not been set), then set // "default" to the CommonJS "module.exports" for node compatibility. isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod )); var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); // virtual:/__injected-globals.js var fetch; var init_injected_globals = __esm({ "virtual:/__injected-globals.js"() { fetch = /* @__PURE__ */ (function(originalFetch) { const getURlFromArgs = (...args) => { const [urlArg] = args; let url; if (typeof urlArg === "string") { url = urlArg; } else if (urlArg instanceof Request) { url = urlArg.url; } else { url = `${urlArg.protocol}//${urlArg.host}${urlArg.pathname}`; } return url; }; const isFirstPartyURL = (url) => { return url.startsWith(window.location.origin) || url.startsWith("/") || url.startsWith("https://created.app"); }; return async function fetchWithHeaders(input, init = {}) { const url = getURlFromArgs(input, init); const isExternalFetch = !isFirstPartyURL(url); if (isExternalFetch) { return originalFetch(input, init); } const initHeaders = init?.headers ?? {}; const finalHeaders = new Headers(initHeaders); finalHeaders.set("x-createxyz-project-id", "26299827-f11a-4d4d-b5cf-6dc57c3cabfe"); finalHeaders.set("x-createxyz-project-group-id", "1e8602fe-4ce0-455e-a096-7ba0817c37dc"); if (input instanceof Request) { input.headers.set("x-createxyz-project-id", "26299827-f11a-4d4d-b5cf-6dc57c3cabfe"); input.headers.set("x-createxyz-project-group-id", "1e8602fe-4ce0-455e-a096-7ba0817c37dc"); } return originalFetch(input, { ...init, headers: finalHeaders }); }; })(globalThis.fetch); } }); // global-externals:react var require_react = __commonJS({ "global-externals:react"(exports, module) { init_injected_globals(); module.exports = React; } }); // global-externals:@auth/create/react var require_react2 = __commonJS({ "global-externals:@auth/create/react"(exports, module) { init_injected_globals(); module.exports = NextAuthReact; } }); // ../../../node_modules/react/cjs/react-jsx-runtime.production.min.js var require_react_jsx_runtime_production_min = __commonJS({ "../../../node_modules/react/cjs/react-jsx-runtime.production.min.js"(exports) { "use strict"; init_injected_globals(); var f = require_react(); var k = Symbol.for("react.element"); var l = Symbol.for("react.fragment"); var m = Object.prototype.hasOwnProperty; var n = f.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner; var p = { key: true, ref: true, __self: true, __source: true }; function q(c, a, g) { var b, d = {}, e = null, h = null; void 0 !== g && (e = "" + g); void 0 !== a.key && (e = "" + a.key); void 0 !== a.ref && (h = a.ref); for (b in a) m.call(a, b) && !p.hasOwnProperty(b) && (d[b] = a[b]); if (c && c.defaultProps) for (b in a = c.defaultProps, a) void 0 === d[b] && (d[b] = a[b]); return { $$typeof: k, type: c, key: e, ref: h, props: d, _owner: n.current }; } exports.Fragment = l; exports.jsx = q; exports.jsxs = q; } }); // ../../../node_modules/react/jsx-runtime.js var require_jsx_runtime = __commonJS({ "../../../node_modules/react/jsx-runtime.js"(exports, module) { "use strict"; init_injected_globals(); if (true) { module.exports = require_react_jsx_runtime_production_min(); } else { module.exports = null; } } }); // virtual:/__wrapped_entry__.jsx var wrapped_entry_exports = {}; __export(wrapped_entry_exports, { default: () => WrappedPage }); init_injected_globals(); var import_react6 = __toESM(require_react()); // virtual:/apps/web/src/app/account/signin/page.jsx init_injected_globals(); var import_react4 = __toESM(require_react()); // ../../../node_modules/react-hook-form/dist/index.esm.mjs init_injected_globals(); var import_react = __toESM(require_react(), 1); var isCheckBoxInput = (element) => element.type === "checkbox"; var isDateObject = (value) => value instanceof Date; var isNullOrUndefined = (value) => value == null; var isObjectType = (value) => typeof value === "object"; var isObject = (value) => !isNullOrUndefined(value) && !Array.isArray(value) && isObjectType(value) && !isDateObject(value); var getEventValue = (event) => isObject(event) && event.target ? isCheckBoxInput(event.target) ? event.target.checked : event.target.value : event; var getNodeParentName = (name) => name.substring(0, name.search(/\.\d+(\.|$)/)) || name; var isNameInFieldArray = (names, name) => names.has(getNodeParentName(name)); var isPlainObject = (tempObject) => { const prototypeCopy = tempObject.constructor && tempObject.constructor.prototype; return isObject(prototypeCopy) && prototypeCopy.hasOwnProperty("isPrototypeOf"); }; var isWeb = typeof window !== "undefined" && typeof window.HTMLElement !== "undefined" && typeof document !== "undefined"; function cloneObject(data) { let copy; const isArray = Array.isArray(data); const isFileListInstance = typeof FileList !== "undefined" ? data instanceof FileList : false; if (data instanceof Date) { copy = new Date(data); } else if (data instanceof Set) { copy = new Set(data); } else if (!(isWeb && (data instanceof Blob || isFileListInstance)) && (isArray || isObject(data))) { copy = isArray ? [] : {}; if (!isArray && !isPlainObject(data)) { copy = data; } else { for (const key in data) { if (data.hasOwnProperty(key)) { copy[key] = cloneObject(data[key]); } } } } else { return data; } return copy; } var compact = (value) => Array.isArray(value) ? value.filter(Boolean) : []; var isUndefined = (val) => val === void 0; var get = (object, path, defaultValue) => { if (!path || !isObject(object)) { return defaultValue; } const result = compact(path.split(/[,[\].]+?/)).reduce((result2, key) => isNullOrUndefined(result2) ? result2 : result2[key], object); return isUndefined(result) || result === object ? isUndefined(object[path]) ? defaultValue : object[path] : result; }; var isBoolean = (value) => typeof value === "boolean"; var isKey = (value) => /^\w*$/.test(value); var stringToPath = (input) => compact(input.replace(/["|']|\]/g, "").split(/\.|\[/)); var set = (object, path, value) => { let index = -1; const tempPath = isKey(path) ? [path] : stringToPath(path); const length = tempPath.length; const lastIndex = length - 1; while (++index < length) { const key = tempPath[index]; let newValue = value; if (index !== lastIndex) { const objValue = object[key]; newValue = isObject(objValue) || Array.isArray(objValue) ? objValue : !isNaN(+tempPath[index + 1]) ? [] : {}; } if (key === "__proto__" || key === "constructor" || key === "prototype") { return; } object[key] = newValue; object = object[key]; } }; var EVENTS = { BLUR: "blur", FOCUS_OUT: "focusout", CHANGE: "change" }; var VALIDATION_MODE = { onBlur: "onBlur", onChange: "onChange", onSubmit: "onSubmit", onTouched: "onTouched", all: "all" }; var INPUT_VALIDATION_RULES = { max: "max", min: "min", maxLength: "maxLength", minLength: "minLength", pattern: "pattern", required: "required", validate: "validate" }; var HookFormContext = import_react.default.createContext(null); var getProxyFormState = (formState, control, localProxyFormState, isRoot = true) => { const result = { defaultValues: control._defaultValues }; for (const key in formState) { Object.defineProperty(result, key, { get: () => { const _key = key; if (control._proxyFormState[_key] !== VALIDATION_MODE.all) { control._proxyFormState[_key] = !isRoot || VALIDATION_MODE.all; } localProxyFormState && (localProxyFormState[_key] = true); return formState[_key]; } }); } return result; }; var isString = (value) => typeof value === "string"; var generateWatchOutput = (names, _names, formValues, isGlobal, defaultValue) => { if (isString(names)) { isGlobal && _names.watch.add(names); return get(formValues, names, defaultValue); } if (Array.isArray(names)) { return names.map((fieldName) => (isGlobal && _names.watch.add(fieldName), get(formValues, fieldName))); } isGlobal && (_names.watchAll = true); return formValues; }; var appendErrors = (name, validateAllFieldCriteria, errors, type, message) => validateAllFieldCriteria ? { ...errors[name], types: { ...errors[name] && errors[name].types ? errors[name].types : {}, [type]: message || true } } : {}; var convertToArrayPayload = (value) => Array.isArray(value) ? value : [value]; var createSubject = () => { let _observers = []; const next = (value) => { for (const observer of _observers) { observer.next && observer.next(value); } }; const subscribe = (observer) => { _observers.push(observer); return { unsubscribe: () => { _observers = _observers.filter((o) => o !== observer); } }; }; const unsubscribe = () => { _observers = []; }; return { get observers() { return _observers; }, next, subscribe, unsubscribe }; }; var isPrimitive = (value) => isNullOrUndefined(value) || !isObjectType(value); function deepEqual(object1, object2) { if (isPrimitive(object1) || isPrimitive(object2)) { return object1 === object2; } if (isDateObject(object1) && isDateObject(object2)) { return object1.getTime() === object2.getTime(); } const keys1 = Object.keys(object1); const keys2 = Object.keys(object2); if (keys1.length !== keys2.length) { return false; } for (const key of keys1) { const val1 = object1[key]; if (!keys2.includes(key)) { return false; } if (key !== "ref") { const val2 = object2[key]; if (isDateObject(val1) && isDateObject(val2) || isObject(val1) && isObject(val2) || Array.isArray(val1) && Array.isArray(val2) ? !deepEqual(val1, val2) : val1 !== val2) { return false; } } } return true; } var isEmptyObject = (value) => isObject(value) && !Object.keys(value).length; var isFileInput = (element) => element.type === "file"; var isFunction = (value) => typeof value === "function"; var isHTMLElement = (value) => { if (!isWeb) { return false; } const owner = value ? value.ownerDocument : 0; return value instanceof (owner && owner.defaultView ? owner.defaultView.HTMLElement : HTMLElement); }; var isMultipleSelect = (element) => element.type === `select-multiple`; var isRadioInput = (element) => element.type === "radio"; var isRadioOrCheckbox = (ref) => isRadioInput(ref) || isCheckBoxInput(ref); var live = (ref) => isHTMLElement(ref) && ref.isConnected; function baseGet(object, updatePath) { const length = updatePath.slice(0, -1).length; let index = 0; while (index < length) { object = isUndefined(object) ? index++ : object[updatePath[index++]]; } return object; } function isEmptyArray(obj) { for (const key in obj) { if (obj.hasOwnProperty(key) && !isUndefined(obj[key])) { return false; } } return true; } function unset(object, path) { const paths = Array.isArray(path) ? path : isKey(path) ? [path] : stringToPath(path); const childObject = paths.length === 1 ? object : baseGet(object, paths); const index = paths.length - 1; const key = paths[index]; if (childObject) { delete childObject[key]; } if (index !== 0 && (isObject(childObject) && isEmptyObject(childObject) || Array.isArray(childObject) && isEmptyArray(childObject))) { unset(object, paths.slice(0, -1)); } return object; } var objectHasFunction = (data) => { for (const key in data) { if (isFunction(data[key])) { return true; } } return false; }; function markFieldsDirty(data, fields = {}) { const isParentNodeArray = Array.isArray(data); if (isObject(data) || isParentNodeArray) { for (const key in data) { if (Array.isArray(data[key]) || isObject(data[key]) && !objectHasFunction(data[key])) { fields[key] = Array.isArray(data[key]) ? [] : {}; markFieldsDirty(data[key], fields[key]); } else if (!isNullOrUndefined(data[key])) { fields[key] = true; } } } return fields; } function getDirtyFieldsFromDefaultValues(data, formValues, dirtyFieldsFromValues) { const isParentNodeArray = Array.isArray(data); if (isObject(data) || isParentNodeArray) { for (const key in data) { if (Array.isArray(data[key]) || isObject(data[key]) && !objectHasFunction(data[key])) { if (isUndefined(formValues) || isPrimitive(dirtyFieldsFromValues[key])) { dirtyFieldsFromValues[key] = Array.isArray(data[key]) ? markFieldsDirty(data[key], []) : { ...markFieldsDirty(data[key]) }; } else { getDirtyFieldsFromDefaultValues(data[key], isNullOrUndefined(formValues) ? {} : formValues[key], dirtyFieldsFromValues[key]); } } else { dirtyFieldsFromValues[key] = !deepEqual(data[key], formValues[key]); } } } return dirtyFieldsFromValues; } var getDirtyFields = (defaultValues, formValues) => getDirtyFieldsFromDefaultValues(defaultValues, formValues, markFieldsDirty(formValues)); var defaultResult = { value: false, isValid: false }; var validResult = { value: true, isValid: true }; var getCheckboxValue = (options) => { if (Array.isArray(options)) { if (options.length > 1) { const values = options.filter((option) => option && option.checked && !option.disabled).map((option) => option.value); return { value: values, isValid: !!values.length }; } return options[0].checked && !options[0].disabled ? ( // @ts-expect-error expected to work in the browser options[0].attributes && !isUndefined(options[0].attributes.value) ? isUndefined(options[0].value) || options[0].value === "" ? validResult : { value: options[0].value, isValid: true } : validResult ) : defaultResult; } return defaultResult; }; var getFieldValueAs = (value, { valueAsNumber, valueAsDate, setValueAs }) => isUndefined(value) ? value : valueAsNumber ? value === "" ? NaN : value ? +value : value : valueAsDate && isString(value) ? new Date(value) : setValueAs ? setValueAs(value) : value; var defaultReturn = { isValid: false, value: null }; var getRadioValue = (options) => Array.isArray(options) ? options.reduce((previous, option) => option && option.checked && !option.disabled ? { isValid: true, value: option.value } : previous, defaultReturn) : defaultReturn; function getFieldValue(_f) { const ref = _f.ref; if (isFileInput(ref)) { return ref.files; } if (isRadioInput(ref)) { return getRadioValue(_f.refs).value; } if (isMultipleSelect(ref)) { return [...ref.selectedOptions].map(({ value }) => value); } if (isCheckBoxInput(ref)) { return getCheckboxValue(_f.refs).value; } return getFieldValueAs(isUndefined(ref.value) ? _f.ref.value : ref.value, _f); } var getResolverOptions = (fieldsNames, _fields, criteriaMode, shouldUseNativeValidation) => { const fields = {}; for (const name of fieldsNames) { const field = get(_fields, name); field && set(fields, name, field._f); } return { criteriaMode, names: [...fieldsNames], fields, shouldUseNativeValidation }; }; var isRegex = (value) => value instanceof RegExp; var getRuleValue = (rule) => isUndefined(rule) ? rule : isRegex(rule) ? rule.source : isObject(rule) ? isRegex(rule.value) ? rule.value.source : rule.value : rule; var getValidationModes = (mode) => ({ isOnSubmit: !mode || mode === VALIDATION_MODE.onSubmit, isOnBlur: mode === VALIDATION_MODE.onBlur, isOnChange: mode === VALIDATION_MODE.onChange, isOnAll: mode === VALIDATION_MODE.all, isOnTouch: mode === VALIDATION_MODE.onTouched }); var ASYNC_FUNCTION = "AsyncFunction"; var hasPromiseValidation = (fieldReference) => !!fieldReference && !!fieldReference.validate && !!(isFunction(fieldReference.validate) && fieldReference.validate.constructor.name === ASYNC_FUNCTION || isObject(fieldReference.validate) && Object.values(fieldReference.validate).find((validateFunction) => validateFunction.constructor.name === ASYNC_FUNCTION)); var hasValidation = (options) => options.mount && (options.required || options.min || options.max || options.maxLength || options.minLength || options.pattern || options.validate); var isWatched = (name, _names, isBlurEvent) => !isBlurEvent && (_names.watchAll || _names.watch.has(name) || [..._names.watch].some((watchName) => name.startsWith(watchName) && /^\.\w+/.test(name.slice(watchName.length)))); var iterateFieldsByAction = (fields, action, fieldsNames, abortEarly) => { for (const key of fieldsNames || Object.keys(fields)) { const field = get(fields, key); if (field) { const { _f, ...currentField } = field; if (_f) { if (_f.refs && _f.refs[0] && action(_f.refs[0], key) && !abortEarly) { return true; } else if (_f.ref && action(_f.ref, _f.name) && !abortEarly) { return true; } else { if (iterateFieldsByAction(currentField, action)) { break; } } } else if (isObject(currentField)) { if (iterateFieldsByAction(currentField, action)) { break; } } } } return; }; function schemaErrorLookup(errors, _fields, name) { const error = get(errors, name); if (error || isKey(name)) { return { error, name }; } const names = name.split("."); while (names.length) { const fieldName = names.join("."); const field = get(_fields, fieldName); const foundError = get(errors, fieldName); if (field && !Array.isArray(field) && name !== fieldName) { return { name }; } if (foundError && foundError.type) { return { name: fieldName, error: foundError }; } names.pop(); } return { name }; } var shouldRenderFormState = (formStateData, _proxyFormState, updateFormState, isRoot) => { updateFormState(formStateData); const { name, ...formState } = formStateData; return isEmptyObject(formState) || Object.keys(formState).length >= Object.keys(_proxyFormState).length || Object.keys(formState).find((key) => _proxyFormState[key] === (!isRoot || VALIDATION_MODE.all)); }; var shouldSubscribeByName = (name, signalName, exact) => !name || !signalName || name === signalName || convertToArrayPayload(name).some((currentName) => currentName && (exact ? currentName === signalName : currentName.startsWith(signalName) || signalName.startsWith(currentName))); var skipValidation = (isBlurEvent, isTouched, isSubmitted, reValidateMode, mode) => { if (mode.isOnAll) { return false; } else if (!isSubmitted && mode.isOnTouch) { return !(isTouched || isBlurEvent); } else if (isSubmitted ? reValidateMode.isOnBlur : mode.isOnBlur) { return !isBlurEvent; } else if (isSubmitted ? reValidateMode.isOnChange : mode.isOnChange) { return isBlurEvent; } return true; }; var unsetEmptyArray = (ref, name) => !compact(get(ref, name)).length && unset(ref, name); var updateFieldArrayRootError = (errors, error, name) => { const fieldArrayErrors = convertToArrayPayload(get(errors, name)); set(fieldArrayErrors, "root", error[name]); set(errors, name, fieldArrayErrors); return errors; }; var isMessage = (value) => isString(value); function getValidateError(result, ref, type = "validate") { if (isMessage(result) || Array.isArray(result) && result.every(isMessage) || isBoolean(result) && !result) { return { type, message: isMessage(result) ? result : "", ref }; } } var getValueAndMessage = (validationData) => isObject(validationData) && !isRegex(validationData) ? validationData : { value: validationData, message: "" }; var validateField = async (field, disabledFieldNames, formValues, validateAllFieldCriteria, shouldUseNativeValidation, isFieldArray) => { const { ref, refs, required, maxLength, minLength, min, max, pattern, validate, name, valueAsNumber, mount } = field._f; const inputValue = get(formValues, name); if (!mount || disabledFieldNames.has(name)) { return {}; } const inputRef = refs ? refs[0] : ref; const setCustomValidity = (message) => { if (shouldUseNativeValidation && inputRef.reportValidity) { inputRef.setCustomValidity(isBoolean(message) ? "" : message || ""); inputRef.reportValidity(); } }; const error = {}; const isRadio = isRadioInput(ref); const isCheckBox = isCheckBoxInput(ref); const isRadioOrCheckbox2 = isRadio || isCheckBox; const isEmpty = (valueAsNumber || isFileInput(ref)) && isUndefined(ref.value) && isUndefined(inputValue) || isHTMLElement(ref) && ref.value === "" || inputValue === "" || Array.isArray(inputValue) && !inputValue.length; const appendErrorsCurry = appendErrors.bind(null, name, validateAllFieldCriteria, error); const getMinMaxMessage = (exceedMax, maxLengthMessage, minLengthMessage, maxType = INPUT_VALIDATION_RULES.maxLength, minType = INPUT_VALIDATION_RULES.minLength) => { const message = exceedMax ? maxLengthMessage : minLengthMessage; error[name] = { type: exceedMax ? maxType : minType, message, ref, ...appendErrorsCurry(exceedMax ? maxType : minType, message) }; }; if (isFieldArray ? !Array.isArray(inputValue) || !inputValue.length : required && (!isRadioOrCheckbox2 && (isEmpty || isNullOrUndefined(inputValue)) || isBoolean(inputValue) && !inputValue || isCheckBox && !getCheckboxValue(refs).isValid || isRadio && !getRadioValue(refs).isValid)) { const { value, message } = isMessage(required) ? { value: !!required, message: required } : getValueAndMessage(required); if (value) { error[name] = { type: INPUT_VALIDATION_RULES.required, message, ref: inputRef, ...appendErrorsCurry(INPUT_VALIDATION_RULES.required, message) }; if (!validateAllFieldCriteria) { setCustomValidity(message); return error; } } } if (!isEmpty && (!isNullOrUndefined(min) || !isNullOrUndefined(max))) { let exceedMax; let exceedMin; const maxOutput = getValueAndMessage(max); const minOutput = getValueAndMessage(min); if (!isNullOrUndefined(inputValue) && !isNaN(inputValue)) { const valueNumber = ref.valueAsNumber || (inputValue ? +inputValue : inputValue); if (!isNullOrUndefined(maxOutput.value)) { exceedMax = valueNumber > maxOutput.value; } if (!isNullOrUndefined(minOutput.value)) { exceedMin = valueNumber < minOutput.value; } } else { const valueDate = ref.valueAsDate || new Date(inputValue); const convertTimeToDate = (time) => /* @__PURE__ */ new Date((/* @__PURE__ */ new Date()).toDateString() + " " + time); const isTime = ref.type == "time"; const isWeek = ref.type == "week"; if (isString(maxOutput.value) && inputValue) { exceedMax = isTime ? convertTimeToDate(inputValue) > convertTimeToDate(maxOutput.value) : isWeek ? inputValue > maxOutput.value : valueDate > new Date(maxOutput.value); } if (isString(minOutput.value) && inputValue) { exceedMin = isTime ? convertTimeToDate(inputValue) < convertTimeToDate(minOutput.value) : isWeek ? inputValue < minOutput.value : valueDate < new Date(minOutput.value); } } if (exceedMax || exceedMin) { getMinMaxMessage(!!exceedMax, maxOutput.message, minOutput.message, INPUT_VALIDATION_RULES.max, INPUT_VALIDATION_RULES.min); if (!validateAllFieldCriteria) { setCustomValidity(error[name].message); return error; } } } if ((maxLength || minLength) && !isEmpty && (isString(inputValue) || isFieldArray && Array.isArray(inputValue))) { const maxLengthOutput = getValueAndMessage(maxLength); const minLengthOutput = getValueAndMessage(minLength); const exceedMax = !isNullOrUndefined(maxLengthOutput.value) && inputValue.length > +maxLengthOutput.value; const exceedMin = !isNullOrUndefined(minLengthOutput.value) && inputValue.length < +minLengthOutput.value; if (exceedMax || exceedMin) { getMinMaxMessage(exceedMax, maxLengthOutput.message, minLengthOutput.message); if (!validateAllFieldCriteria) { setCustomValidity(error[name].message); return error; } } } if (pattern && !isEmpty && isString(inputValue)) { const { value: patternValue, message } = getValueAndMessage(pattern); if (isRegex(patternValue) && !inputValue.match(patternValue)) { error[name] = { type: INPUT_VALIDATION_RULES.pattern, message, ref, ...appendErrorsCurry(INPUT_VALIDATION_RULES.pattern, message) }; if (!validateAllFieldCriteria) { setCustomValidity(message); return error; } } } if (validate) { if (isFunction(validate)) { const result = await validate(inputValue, formValues); const validateError = getValidateError(result, inputRef); if (validateError) { error[name] = { ...validateError, ...appendErrorsCurry(INPUT_VALIDATION_RULES.validate, validateError.message) }; if (!validateAllFieldCriteria) { setCustomValidity(validateError.message); return error; } } } else if (isObject(validate)) { let validationResult = {}; for (const key in validate) { if (!isEmptyObject(validationResult) && !validateAllFieldCriteria) { break; } const validateError = getValidateError(await validate[key](inputValue, formValues), inputRef, key); if (validateError) { validationResult = { ...validateError, ...appendErrorsCurry(key, validateError.message) }; setCustomValidity(validateError.message); if (validateAllFieldCriteria) { error[name] = validationResult; } } } if (!isEmptyObject(validationResult)) { error[name] = { ref: inputRef, ...validationResult }; if (!validateAllFieldCriteria) { return error; } } } } setCustomValidity(true); return error; }; var defaultOptions = { mode: VALIDATION_MODE.onSubmit, reValidateMode: VALIDATION_MODE.onChange, shouldFocusError: true }; function createFormControl(props = {}) { let _options = { ...defaultOptions, ...props }; let _formState = { submitCount: 0, isDirty: false, isLoading: isFunction(_options.defaultValues), isValidating: false, isSubmitted: false, isSubmitting: false, isSubmitSuccessful: false, isValid: false, touchedFields: {}, dirtyFields: {}, validatingFields: {}, errors: _options.errors || {}, disabled: _options.disabled || false }; const _fields = {}; let _defaultValues = isObject(_options.defaultValues) || isObject(_options.values) ? cloneObject(_options.values || _options.defaultValues) || {} : {}; let _formValues = _options.shouldUnregister ? {} : cloneObject(_defaultValues); let _state = { action: false, mount: false, watch: false }; let _names = { mount: /* @__PURE__ */ new Set(), disabled: /* @__PURE__ */ new Set(), unMount: /* @__PURE__ */ new Set(), array: /* @__PURE__ */ new Set(), watch: /* @__PURE__ */ new Set() }; let delayErrorCallback; let timer = 0; const _proxyFormState = { isDirty: false, dirtyFields: false, validatingFields: false, touchedFields: false, isValidating: false, isValid: false, errors: false }; let _proxySubscribeFormState = { ..._proxyFormState }; const _subjects = { array: createSubject(), state: createSubject() }; const validationModeBeforeSubmit = getValidationModes(_options.mode); const validationModeAfterSubmit = getValidationModes(_options.reValidateMode); const shouldDisplayAllAssociatedErrors = _options.criteriaMode === VALIDATION_MODE.all; const debounce = (callback) => (wait) => { clearTimeout(timer); timer = setTimeout(callback, wait); }; const _setValid = async (shouldUpdateValid) => { if (!_options.disabled && (_proxyFormState.isValid || _proxySubscribeFormState.isValid || shouldUpdateValid)) { const isValid = _options.resolver ? isEmptyObject((await _runSchema()).errors) : await executeBuiltInValidation(_fields, true); if (isValid !== _formState.isValid) { _subjects.state.next({ isValid }); } } }; const _updateIsValidating = (names, isValidating) => { if (!_options.disabled && (_proxyFormState.isValidating || _proxyFormState.validatingFields || _proxySubscribeFormState.isValidating || _proxySubscribeFormState.validatingFields)) { (names || Array.from(_names.mount)).forEach((name) => { if (name) { isValidating ? set(_formState.validatingFields, name, isValidating) : unset(_formState.validatingFields, name); } }); _subjects.state.next({ validatingFields: _formState.validatingFields, isValidating: !isEmptyObject(_formState.validatingFields) }); } }; const _setFieldArray = (name, values = [], method, args, shouldSetValues = true, shouldUpdateFieldsAndState = true) => { if (args && method && !_options.disabled) { _state.action = true; if (shouldUpdateFieldsAndState && Array.isArray(get(_fields, name))) { const fieldValues = method(get(_fields, name), args.argA, args.argB); shouldSetValues && set(_fields, name, fieldValues); } if (shouldUpdateFieldsAndState && Array.isArray(get(_formState.errors, name))) { const errors = method(get(_formState.errors, name), args.argA, args.argB); shouldSetValues && set(_formState.errors, name, errors); unsetEmptyArray(_formState.errors, name); } if ((_proxyFormState.touchedFields || _proxySubscribeFormState.touchedFields) && shouldUpdateFieldsAndState && Array.isArray(get(_formState.touchedFields, name))) { const touchedFields = method(get(_formState.touchedFields, name), args.argA, args.argB); shouldSetValues && set(_formState.touchedFields, name, touchedFields); } if (_proxyFormState.dirtyFields || _proxySubscribeFormState.dirtyFields) { _formState.dirtyFields = getDirtyFields(_defaultValues, _formValues); } _subjects.state.next({ name, isDirty: _getDirty(name, values), dirtyFields: _formState.dirtyFields, errors: _formState.errors, isValid: _formState.isValid }); } else { set(_formValues, name, values); } }; const updateErrors = (name, error) => { set(_formState.errors, name, error); _subjects.state.next({ errors: _formState.errors }); }; const _setErrors = (errors) => { _formState.errors = errors; _subjects.state.next({ errors: _formState.errors, isValid: false }); }; const updateValidAndValue = (name, shouldSkipSetValueAs, value, ref) => { const field = get(_fields, name); if (field) { const defaultValue = get(_formValues, name, isUndefined(value) ? get(_defaultValues, name) : value); isUndefined(defaultValue) || ref && ref.defaultChecked || shouldSkipSetValueAs ? set(_formValues, name, shouldSkipSetValueAs ? defaultValue : getFieldValue(field._f)) : setFieldValue(name, defaultValue); _state.mount && _setValid(); } }; const updateTouchAndDirty = (name, fieldValue, isBlurEvent, shouldDirty, shouldRender) => { let shouldUpdateField = false; let isPreviousDirty = false; const output = { name }; if (!_options.disabled) { if (!isBlurEvent || shouldDirty) { if (_proxyFormState.isDirty || _proxySubscribeFormState.isDirty) { isPreviousDirty = _formState.isDirty; _formState.isDirty = output.isDirty = _getDirty(); shouldUpdateField = isPreviousDirty !== output.isDirty; } const isCurrentFieldPristine = deepEqual(get(_defaultValues, name), fieldValue); isPreviousDirty = !!get(_formState.dirtyFields, name); isCurrentFieldPristine ? unset(_formState.dirtyFields, name) : set(_formState.dirtyFields, name, true); output.dirtyFields = _formState.dirtyFields; shouldUpdateField = shouldUpdateField || (_proxyFormState.dirtyFields || _proxySubscribeFormState.dirtyFields) && isPreviousDirty !== !isCurrentFieldPristine; } if (isBlurEvent) { const isPreviousFieldTouched = get(_formState.touchedFields, name); if (!isPreviousFieldTouched) { set(_formState.touchedFields, name, isBlurEvent); output.touchedFields = _formState.touchedFields; shouldUpdateField = shouldUpdateField || (_proxyFormState.touchedFields || _proxySubscribeFormState.touchedFields) && isPreviousFieldTouched !== isBlurEvent; } } shouldUpdateField && shouldRender && _subjects.state.next(output); } return shouldUpdateField ? output : {}; }; const shouldRenderByError = (name, isValid, error, fieldState) => { const previousFieldError = get(_formState.errors, name); const shouldUpdateValid = (_proxyFormState.isValid || _proxySubscribeFormState.isValid) && isBoolean(isValid) && _formState.isValid !== isValid; if (_options.delayError && error) { delayErrorCallback = debounce(() => updateErrors(name, error)); delayErrorCallback(_options.delayError); } else { clearTimeout(timer); delayErrorCallback = null; error ? set(_formState.errors, name, error) : unset(_formState.errors, name); } if ((error ? !deepEqual(previousFieldError, error) : previousFieldError) || !isEmptyObject(fieldState) || shouldUpdateValid) { const updatedFormState = { ...fieldState, ...shouldUpdateValid && isBoolean(isValid) ? { isValid } : {}, errors: _formState.errors, name }; _formState = { ..._formState, ...updatedFormState }; _subjects.state.next(updatedFormState); } }; const _runSchema = async (name) => { _updateIsValidating(name, true); const result = await _options.resolver(_formValues, _options.context, getResolverOptions(name || _names.mount, _fields, _options.criteriaMode, _options.shouldUseNativeValidation)); _updateIsValidating(name); return result; }; const executeSchemaAndUpdateState = async (names) => { const { errors } = await _runSchema(names); if (names) { for (const name of names) { const error = get(errors, name); error ? set(_formState.errors, name, error) : unset(_formState.errors, name); } } else { _formState.errors = errors; } return errors; }; const executeBuiltInValidation = async (fields, shouldOnlyCheckValid, context = { valid: true }) => { for (const name in fields) { const field = fields[name]; if (field) { const { _f, ...fieldValue } = field; if (_f) { const isFieldArrayRoot = _names.array.has(_f.name); const isPromiseFunction = field._f && hasPromiseValidation(field._f); if (isPromiseFunction && _proxyFormState.validatingFields) { _updateIsValidating([name], true); } const fieldError = await validateField(field, _names.disabled, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation && !shouldOnlyCheckValid, isFieldArrayRoot); if (isPromiseFunction && _proxyFormState.validatingFields) { _updateIsValidating([name]); } if (fieldError[_f.name]) { context.valid = false; if (shouldOnlyCheckValid) { break; } } !shouldOnlyCheckValid && (get(fieldError, _f.name) ? isFieldArrayRoot ? updateFieldArrayRootError(_formState.errors, fieldError, _f.name) : set(_formState.errors, _f.name, fieldError[_f.name]) : unset(_formState.errors, _f.name)); } !isEmptyObject(fieldValue) && await executeBuiltInValidation(fieldValue, shouldOnlyCheckValid, context); } } return context.valid; }; const _removeUnmounted = () => { for (const name of _names.unMount) { const field = get(_fields, name); field && (field._f.refs ? field._f.refs.every((ref) => !live(ref)) : !live(field._f.ref)) && unregister(name); } _names.unMount = /* @__PURE__ */ new Set(); }; const _getDirty = (name, data) => !_options.disabled && (name && data && set(_formValues, name, data), !deepEqual(getValues(), _defaultValues)); const _getWatch = (names, defaultValue, isGlobal) => generateWatchOutput(names, _names, { ..._state.mount ? _formValues : isUndefined(defaultValue) ? _defaultValues : isString(names) ? { [names]: defaultValue } : defaultValue }, isGlobal, defaultValue); const _getFieldArray = (name) => compact(get(_state.mount ? _formValues : _defaultValues, name, _options.shouldUnregister ? get(_defaultValues, name, []) : [])); const setFieldValue = (name, value, options = {}) => { const field = get(_fields, name); let fieldValue = value; if (field) { const fieldReference = field._f; if (fieldReference) { !fieldReference.disabled && set(_formValues, name, getFieldValueAs(value, fieldReference)); fieldValue = isHTMLElement(fieldReference.ref) && isNullOrUndefined(value) ? "" : value; if (isMultipleSelect(fieldReference.ref)) { [...fieldReference.ref.options].forEach((optionRef) => optionRef.selected = fieldValue.includes(optionRef.value)); } else if (fieldReference.refs) { if (isCheckBoxInput(fieldReference.ref)) { fieldReference.refs.length > 1 ? fieldReference.refs.forEach((checkboxRef) => (!checkboxRef.defaultChecked || !checkboxRef.disabled) && (checkboxRef.checked = Array.isArray(fieldValue) ? !!fieldValue.find((data) => data === checkboxRef.value) : fieldValue === checkboxRef.value)) : fieldReference.refs[0] && (fieldReference.refs[0].checked = !!fieldValue); } else { fieldReference.refs.forEach((radioRef) => radioRef.checked = radioRef.value === fieldValue); } } else if (isFileInput(fieldReference.ref)) { fieldReference.ref.value = ""; } else { fieldReference.ref.value = fieldValue; if (!fieldReference.ref.type) { _subjects.state.next({ name, values: cloneObject(_formValues) }); } } } } (options.shouldDirty || options.shouldTouch) && updateTouchAndDirty(name, fieldValue, options.shouldTouch, options.shouldDirty, true); options.shouldValidate && trigger(name); }; const setValues = (name, value, options) => { for (const fieldKey in value) { const fieldValue = value[fieldKey]; const fieldName = `${name}.${fieldKey}`; const field = get(_fields, fieldName); (_names.array.has(name) || isObject(fieldValue) || field && !field._f) && !isDateObject(fieldValue) ? setValues(fieldName, fieldValue, options) : setFieldValue(fieldName, fieldValue, options); } }; const setValue = (name, value, options = {}) => { const field = get(_fields, name); const isFieldArray = _names.array.has(name); const cloneValue = cloneObject(value); set(_formValues, name, cloneValue); if (isFieldArray) { _subjects.array.next({ name, values: cloneObject(_formValues) }); if ((_proxyFormState.isDirty || _proxyFormState.dirtyFields || _proxySubscribeFormState.isDirty || _proxySubscribeFormState.dirtyFields) && options.shouldDirty) { _subjects.state.next({ name, dirtyFields: getDirtyFields(_defaultValues, _formValues), isDirty: _getDirty(name, cloneValue) }); } } else { field && !field._f && !isNullOrUndefined(cloneValue) ? setValues(name, cloneValue, options) : setFieldValue(name, cloneValue, options); } isWatched(name, _names) && _subjects.state.next({ ..._formState }); _subjects.state.next({ name: _state.mount ? name : void 0, values: cloneObject(_formValues) }); }; const onChange = async (event) => { _state.mount = true; const target = event.target; let name = target.name; let isFieldValueUpdated = true; const field = get(_fields, name); const _updateIsFieldValueUpdated = (fieldValue) => { isFieldValueUpdated = Number.isNaN(fieldValue) || isDateObject(fieldValue) && isNaN(fieldValue.getTime()) || deepEqual(fieldValue, get(_formValues, name, fieldValue)); }; if (field) { let error; let isValid; const fieldValue = target.type ? getFieldValue(field._f) : getEventValue(event); const isBlurEvent = event.type === EVENTS.BLUR || event.type === EVENTS.FOCUS_OUT; const shouldSkipValidation = !hasValidation(field._f) && !_options.resolver && !get(_formState.errors, name) && !field._f.deps || skipValidation(isBlurEvent, get(_formState.touchedFields, name), _formState.isSubmitted, validationModeAfterSubmit, validationModeBeforeSubmit); const watched = isWatched(name, _names, isBlurEvent); set(_formValues, name, fieldValue); if (isBlurEvent) { field._f.onBlur && field._f.onBlur(event); delayErrorCallback && delayErrorCallback(0); } else if (field._f.onChange) { field._f.onChange(event); } const fieldState = updateTouchAndDirty(name, fieldValue, isBlurEvent); const shouldRender = !isEmptyObject(fieldState) || watched; !isBlurEvent && _subjects.state.next({ name, type: event.type, values: cloneObject(_formValues) }); if (shouldSkipValidation) { if (_proxyFormState.isValid || _proxySubscribeFormState.isValid) { if (_options.mode === "onBlur") { if (isBlurEvent) { _setValid(); } } else if (!isBlurEvent) { _setValid(); } } return shouldRender && _subjects.state.next({ name, ...watched ? {} : fieldState }); } !isBlurEvent && watched && _subjects.state.next({ ..._formState }); if (_options.resolver) { const { errors } = await _runSchema([name]); _updateIsFieldValueUpdated(fieldValue); if (isFieldValueUpdated) { const previousErrorLookupResult = schemaErrorLookup(_formState.errors, _fields, name); const errorLookupResult = schemaErrorLookup(errors, _fields, previousErrorLookupResult.name || name); error = errorLookupResult.error; name = errorLookupResult.name; isValid = isEmptyObject(errors); } } else { _updateIsValidating([name], true); error = (await validateField(field, _names.disabled, _formValues, shouldDisplayAllAssociatedErrors, _options.shouldUseNativeValidation))[name]; _updateIsValidating([name]); _updateIsFieldValueUpdated(fieldValue); if (isFieldValueUpdated) { if (error) { isValid = false; } else if (_proxyFormState.isValid || _proxySubscribeFormState.isValid) { isValid = await executeBuiltInValidation(_fields, true); } } } if (isFieldValueUpdated) { field._f.deps && trigger(field._f.deps); shouldRenderByError(name, isValid, error, fieldState); } } }; const _focusInput = (ref, key) => { if (get(_formState.errors, key) && ref.focus) { ref.focus(); return 1; } return; }; const trigger = async (name, options = {}) => { let isValid; let validationResult; const fieldNames = convertToArrayPayload(name); if (_options.resolver) { const errors = await executeSchemaAndUpdateState(isUndefined(name) ? name : fieldNames); isValid = isEmptyObject(errors); validationResult = name ? !fieldNames.some((name2) => get(errors, name2)) : isValid; } else if (name) { validationResult = (await Promise.all(fieldNames.map(async (fieldName) => { const field = get(_fields, fieldName); return await executeBuiltInValidation(field && field._f ? { [fieldName]: field } : field); }))).every(Boolean); !(!validationResult && !_formState.isValid) && _setValid(); } else { validationResult = isValid = await executeBuiltInValidation(_fields); } _subjects.state.next({ ...!isString(name) || (_proxyFormState.isValid || _proxySubscribeFormState.isValid) && isValid !== _formState.isValid ? {} : { name }, ..._options.resolver || !name ? { isValid } : {}, errors: _formState.errors }); options.shouldFocus && !validationResult && iterateFieldsByAction(_fields, _focusInput, name ? fieldNames : _names.mount); return validationResult; }; const getValues = (fieldNames) => { const values = { ..._state.mount ? _formValues : _defaultValues }; return isUndefined(fieldNames) ? values : isString(fieldNames) ? get(values, fieldNames) : fieldNames.map((name) => get(values, name)); }; const getFieldState = (name, formState) => ({ invalid: !!get((formState || _formState).errors, name), isDirty: !!get((formState || _formState).dirtyFields, name), error: get((formState || _formState).errors, name), isValidating: !!get(_formState.validatingFields, name), isTouched: !!get((formState || _formState).touchedFields, name) }); const clearErrors = (name) => { name && convertToArrayPayload(name).forEach((inputName) => unset(_formState.errors, inputName)); _subjects.state.next({ errors: name ? _formState.errors : {} }); }; const setError = (name, error, options) => { const ref = (get(_fields, name, { _f: {} })._f || {}).ref; const currentError = get(_formState.errors, name) || {}; const { ref: currentRef, message, type, ...restOfErrorTree } = currentError; set(_formState.errors, name, { ...restOfErrorTree, ...error, ref }); _subjects.state.next({ name, errors: _formState.errors, isValid: false }); options && options.shouldFocus && ref && ref.focus && ref.focus(); }; const watch = (name, defaultValue) => isFunction(name) ? _subjects.state.subscribe({ next: (payload) => name(_getWatch(void 0, defaultValue), payload) }) : _getWatch(name, defaultValue, true); const _subscribe = (props2) => _subjects.state.subscribe({ next: (formState) => { if (shouldSubscribeByName(props2.name, formState.name, props2.exact) && shouldRenderFormState(formState, props2.formState || _proxyFormState, _setFormState, props2.reRenderRoot)) { props2.callback({ values: { ..._formValues }, ..._formState, ...formState }); } } }).unsubscribe; const subscribe = (props2) => { _state.mount = true; _proxySubscribeFormState = { ..._proxySubscribeFormState, ...props2.formState }; return _subscribe({ ...props2, formState: _proxySubscribeFormState }); }; const unregister = (name, options = {}) => { for (const fieldName of name ? convertToArrayPayload(name) : _names.mount) { _names.mount.delete(fieldName); _names.array.delete(fieldName); if (!options.keepValue) { unset(_fields, fieldName); unset(_formValues, fieldName); } !options.keepError && unset(_formState.errors, fieldName); !options.keepDirty && unset(_formState.dirtyFields, fieldName); !options.keepTouched && unset(_formState.touchedFields, fieldName); !options.keepIsValidating && unset(_formState.validatingFields, fieldName); !_options.shouldUnregister && !options.keepDefaultValue && unset(_defaultValues, fieldName); } _subjects.state.next({ values: cloneObject(_formValues) }); _subjects.state.next({ ..._formState, ...!options.keepDirty ? {} : { isDirty: _getDirty() } }); !options.keepIsValid && _setValid(); }; const _setDisabledField = ({ disabled, name }) => { if (isBoolean(disabled) && _state.mount || !!disabled || _names.disabled.has(name)) { disabled ? _names.disabled.add(name) : _names.disabled.delete(name); } }; const register = (name, options = {}) => { let field = get(_fields, name); const disabledIsDefined = isBoolean(options.disabled) || isBoolean(_options.disabled); set(_fields, name, { ...field || {}, _f: { ...field && field._f ? field._f : { ref: { name } }, name, mount: true, ...options } }); _names.mount.add(name); if (field) { _setDisabledField({ disabled: isBoolean(options.disabled) ? options.disabled : _options.disabled, name }); } else { updateValidAndValue(name, true, options.value); } return { ...disabledIsDefined ? { disabled: options.disabled || _options.disabled } : {}, ..._options.progressive ? { required: !!options.required, min: getRuleValue(options.min), max: getRuleValue(options.max), minLength: getRuleValue(options.minLength), maxLength: getRuleValue(options.maxLength), pattern: getRuleValue(options.pattern) } : {}, name, onChange, onBlur: onChange, ref: (ref) => { if (ref) { register(name, options); field = get(_fields, name); const fieldRef = isUndefined(ref.value) ? ref.querySelectorAll ? ref.querySelectorAll("input,select,textarea")[0] || ref : ref : ref; const radioOrCheckbox = isRadioOrCheckbox(fieldRef); const refs = field._f.refs || []; if (radioOrCheckbox ? refs.find((option) => option === fieldRef) : fieldRef === field._f.ref) { return; } set(_fields, name, { _f: { ...field._f, ...radioOrCheckbox ? { refs: [ ...refs.filter(live), fieldRef, ...Array.isArray(get(_defaultValues, name)) ? [{}] : [] ], ref: { type: fieldRef.type, name } } : { ref: fieldRef } } }); updateValidAndValue(name, false, void 0, fieldRef); } else { field = get(_fields, name, {}); if (field._f) { field._f.mount = false; } (_options.shouldUnregister || options.shouldUnregister) && !(isNameInFieldArray(_names.array, name) && _state.action) && _names.unMount.add(name); } } }; }; const _focusError = () => _options.shouldFocusError && iterateFieldsByAction(_fields, _focusInput, _names.mount); const _disableForm = (disabled) => { if (isBoolean(disabled)) { _subjects.state.next({ disabled }); iterateFieldsByAction(_fields, (ref, name) => { const currentField = get(_fields, name); if (currentField) { ref.disabled = currentField._f.disabled || disabled; if (Array.isArray(currentField._f.refs)) { currentField._f.refs.forEach((inputRef) => { inputRef.disabled = currentField._f.disabled || disabled; }); } } }, 0, false); } }; const handleSubmit = (onValid, onInvalid) => async (e) => { let onValidError = void 0; if (e) { e.preventDefault && e.preventDefault(); e.persist && e.persist(); } let fieldValues = cloneObject(_formValues); _subjects.state.next({ isSubmitting: true }); if (_options.resolver) { const { errors, values } = await _runSchema(); _formState.errors = errors; fieldValues = values; } else { await executeBuiltInValidation(_fields); } if (_names.disabled.size) { for (const name of _names.disabled) { set(fieldValues, name, void 0); } } unset(_formState.errors, "root"); if (isEmptyObject(_formState.errors)) { _subjects.state.next({ errors: {} }); try { await onValid(fieldValues, e); } catch (error) { onValidError = error; } } else { if (onInvalid) { await onInvalid({ ..._formState.errors }, e); } _focusError(); setTimeout(_focusError); } _subjects.state.next({ isSubmitted: true, isSubmitting: false, isSubmitSuccessful: isEmptyObject(_formState.errors) && !onValidError, submitCount: _formState.submitCount + 1, errors: _formState.errors }); if (onValidError) { throw onValidError; } }; const resetField = (name, options = {}) => { if (get(_fields, name)) { if (isUndefined(options.defaultValue)) { setValue(name, cloneObject(get(_defaultValues, name))); } else { setValue(name, options.defaultValue); set(_defaultValues, name, cloneObject(options.defaultValue)); } if (!options.keepTouched) { unset(_formState.touchedFields, name); } if (!options.keepDirty) { unset(_formState.dirtyFields, name); _formState.isDirty = options.defaultValue ? _getDirty(name, cloneObject(get(_defaultValues, name))) : _getDirty(); } if (!options.keepError) { unset(_formState.errors, name); _proxyFormState.isValid && _setValid(); } _subjects.state.next({ ..._formState }); } }; const _reset = (formValues, keepStateOptions = {}) => { const updatedValues = formValues ? cloneObject(formValues) : _defaultValues; const cloneUpdatedValues = cloneObject(updatedValues); const isEmptyResetValues = isEmptyObject(formValues); const values = isEmptyResetValues ? _defaultValues : cloneUpdatedValues; if (!keepStateOptions.keepDefaultValues) { _defaultValues = updatedValues; } if (!keepStateOptions.keepValues) { if (keepStateOptions.keepDirtyValues) { const fieldsToCheck = /* @__PURE__ */ new Set([ ..._names.mount, ...Object.keys(getDirtyFields(_defaultValues, _formValues)) ]); for (const fieldName of Array.from(fieldsToCheck)) { get(_formState.dirtyFields, fieldName) ? set(values, fieldName, get(_formValues, fieldName)) : setValue(fieldName, get(values, fieldName)); } } else { if (isWeb && isUndefined(formValues)) { for (const name of _names.mount) { const field = get(_fields, name); if (field && field._f) { const fieldReference = Array.isArray(field._f.refs) ? field._f.refs[0] : field._f.ref; if (isHTMLElement(fieldReference)) { const form = fieldReference.closest("form"); if (form) { form.reset(); break; } } } } } for (const fieldName of _names.mount) { setValue(fieldName, get(values, fieldName)); } } _formValues = cloneObject(values); _subjects.array.next({ values: { ...values } }); _subjects.state.next({ values: { ...values } }); } _names = { mount: keepStateOptions.keepDirtyValues ? _names.mount : /* @__PURE__ */ new Set(), unMount: /* @__PURE__ */ new Set(), array: /* @__PURE__ */ new Set(), disabled: /* @__PURE__ */ new Set(), watch: /* @__PURE__ */ new Set(), watchAll: false, focus: "" }; _state.mount = !_proxyFormState.isValid || !!keepStateOptions.keepIsValid || !!keepStateOptions.keepDirtyValues; _state.watch = !!_options.shouldUnregister; _subjects.state.next({ submitCount: keepStateOptions.keepSubmitCount ? _formState.submitCount : 0, isDirty: isEmptyResetValues ? false : keepStateOptions.keepDirty ? _formState.isDirty : !!(keepStateOptions.keepDefaultValues && !deepEqual(formValues, _defaultValues)), isSubmitted: keepStateOptions.keepIsSubmitted ? _formState.isSubmitted : false, dirtyFields: isEmptyResetValues ? {} : keepStateOptions.keepDirtyValues ? keepStateOptions.keepDefaultValues && _formValues ? getDirtyFields(_defaultValues, _formValues) : _formState.dirtyFields : keepStateOptions.keepDefaultValues && formValues ? getDirtyFields(_defaultValues, formValues) : keepStateOptions.keepDirty ? _formState.dirtyFields : {}, touchedFields: keepStateOptions.keepTouched ? _formState.touchedFields : {}, errors: keepStateOptions.keepErrors ? _formState.errors : {}, isSubmitSuccessful: keepStateOptions.keepIsSubmitSuccessful ? _formState.isSubmitSuccessful : false, isSubmitting: false }); }; const reset = (formValues, keepStateOptions) => _reset(isFunction(formValues) ? formValues(_formValues) : formValues, keepStateOptions); const setFocus = (name, options = {}) => { const field = get(_fields, name); const fieldReference = field && field._f; if (fieldReference) { const fieldRef = fieldReference.refs ? fieldReference.refs[0] : fieldReference.ref; if (fieldRef.focus) { fieldRef.focus(); options.shouldSelect && isFunction(fieldRef.select) && fieldRef.select(); } } }; const _setFormState = (updatedFormState) => { _formState = { ..._formState, ...updatedFormState }; }; const _resetDefaultValues = () => isFunction(_options.defaultValues) && _options.defaultValues().then((values) => { reset(values, _options.resetOptions); _subjects.state.next({ isLoading: false }); }); const methods = { control: { register, unregister, getFieldState, handleSubmit, setError, _subscribe, _runSchema, _getWatch, _getDirty, _setValid, _setFieldArray, _setDisabledField, _setErrors, _getFieldArray, _reset, _resetDefaultValues, _removeUnmounted, _disableForm, _subjects, _proxyFormState, get _fields() { return _fields; }, get _formValues() { return _formValues; }, get _state() { return _state; }, set _state(value) { _state = value; }, get _defaultValues() { return _defaultValues; }, get _names() { return _names; }, set _names(value) { _names = value; }, get _formState() { return _formState; }, get _options() { return _options; }, set _options(value) { _options = { ..._options, ...value }; } }, subscribe, trigger, register, handleSubmit, watch, setValue, getValues, reset, resetField, clearErrors, unregister, setError, setFocus, getFieldState }; return { ...methods, formControl: methods }; } function useForm(props = {}) { const _formControl = import_react.default.useRef(void 0); const _values = import_react.default.useRef(void 0); const [formState, updateFormState] = import_react.default.useState({ isDirty: false, isValidating: false, isLoading: isFunction(props.defaultValues), isSubmitted: false, isSubmitting: false, isSubmitSuccessful: false, isValid: false, submitCount: 0, dirtyFields: {}, touchedFields: {}, validatingFields: {}, errors: props.errors || {}, disabled: props.disabled || false, defaultValues: isFunction(props.defaultValues) ? void 0 : props.defaultValues }); if (!_formControl.current) { _formControl.current = { ...props.formControl ? props.formControl : createFormControl(props), formState }; if (props.formControl && props.defaultValues && !isFunction(props.defaultValues)) { props.formControl.reset(props.defaultValues, props.resetOptions); } } const control = _formControl.current.control; control._options = props; import_react.default.useLayoutEffect(() => control._subscribe({ formState: control._proxyFormState, callback: () => updateFormState({ ...control._formState }), reRenderRoot: true }), [control]); import_react.default.useEffect(() => control._disableForm(props.disabled), [control, props.disabled]); import_react.default.useEffect(() => { if (control._proxyFormState.isDirty) { const isDirty = control._getDirty(); if (isDirty !== formState.isDirty) { control._subjects.state.next({ isDirty }); } } }, [control, formState.isDirty]); import_react.default.useEffect(() => { if (props.values && !deepEqual(props.values, _values.current)) { control._reset(props.values, control._options.resetOptions); _values.current = props.values; updateFormState((state) => ({ ...state })); } else { control._resetDefaultValues(); } }, [props.values, control]); import_react.default.useEffect(() => { if (props.errors && !isEmptyObject(props.errors)) { control._setErrors(props.errors); } }, [props.errors, control]); import_react.default.useEffect(() => { if (!control._state.mount) { control._setValid(); control._state.mount = true; } if (control._state.watch) { control._state.watch = false; control._subjects.state.next({ ...control._formState }); } control._removeUnmounted(); }); import_react.default.useEffect(() => { props.shouldUnregister && control._subjects.state.next({ values: control._getWatch() }); }, [props.shouldUnregister, control]); _formControl.current.formState = getProxyFormState(formState, control); return _formControl.current; } // virtual:/apps/web/src/utils/useAuth.js init_injected_globals(); var import_react2 = __toESM(require_react()); var import_react3 = __toESM(require_react2()); function useAuth() { const callbackUrl = typeof window !== "undefined" ? new URLSearchParams(window.location.search).get("callbackUrl") : null; const signInWithCredentials = (0, import_react2.useCallback)( (options) => { return (0, import_react3.signIn)("credentials-signin", { ...options, callbackUrl: callbackUrl ?? options.callbackUrl }); }, [callbackUrl] ); const signUpWithCredentials = (0, import_react2.useCallback)( (options) => { return (0, import_react3.signIn)("credentials-signup", { ...options, callbackUrl: callbackUrl ?? options.callbackUrl }); }, [callbackUrl] ); const signInWithGoogle = (0, import_react2.useCallback)( (options) => { return (0, import_react3.signIn)("google", { ...options, callbackUrl: callbackUrl ?? options.callbackUrl }); }, [callbackUrl] ); const signInWithFacebook = (0, import_react2.useCallback)((options) => { return (0, import_react3.signIn)("facebook", options); }, []); const signInWithTwitter = (0, import_react2.useCallback)((options) => { return (0, import_react3.signIn)("twitter", options); }, []); return { signInWithCredentials, signUpWithCredentials, signInWithGoogle, signInWithFacebook, signInWithTwitter, signOut: import_react3.signOut }; } var useAuth_default = useAuth; // virtual:/apps/web/src/app/account/signin/page.jsx function SignIn() { const [isLoading, setIsLoading] = (0, import_react4.useState)(false); const [error, setError] = (0, import_react4.useState)(null); const { signInWithCredentials } = useAuth_default(); const { register, handleSubmit, formState: { errors } } = useForm(); const onSubmit = async (data) => { try { setIsLoading(true); setError(null); await signInWithCredentials({ email: data.email, password: data.password, callbackUrl: "/", redirect: false }); window.location.href = "/"; } catch (err) { console.error("Sign in error:", err); setError("Invalid email or password. Please try again."); setIsLoading(false); } }; return /* @__PURE__ */ React.createElement("div", { className: "min-h-screen flex items-center justify-center bg-gradient-to-br from-[#FF6B35]/5 via-white to-[#4ECDC4]/10 px-4 py-8 sm:px-6 lg:px-8" }, /* @__PURE__ */ React.createElement( "button", { onClick: () => window.history.back(), className: "fixed top-3 left-3 sm:top-4 sm:left-4 md:top-6 md:left-6 z-10 w-9 h-9 sm:w-10 sm:h-10 rounded-full bg-white shadow-md flex items-center justify-center hover:bg-gray-50 transition-colors" }, /* @__PURE__ */ React.createElement( "svg", { className: "w-4 h-4 sm:w-5 sm:h-5 text-gray-600", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24" }, /* @__PURE__ */ React.createElement( "path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M15 19l-7-7 7-7" } ) ) ), /* @__PURE__ */ React.createElement( "button", { onClick: () => window.location.href = "/", className: "fixed top-3 left-14 sm:top-4 sm:left-16 md:top-6 md:left-20 z-10 w-9 h-9 sm:w-10 sm:h-10 rounded-full bg-white shadow-md flex items-center justify-center hover:bg-gray-50 transition-colors" }, /* @__PURE__ */ React.createElement( "svg", { className: "w-4 h-4 sm:w-5 sm:h-5 text-gray-600", fill: "none", stroke: "currentColor", viewBox: "0 0 24 24" }, /* @__PURE__ */ React.createElement( "path", { strokeLinecap: "round", strokeLinejoin: "round", strokeWidth: 2, d: "M3 12l2-2m0 0l7-7 7 7M5 10v10a1 1 0 001 1h3m10-11l2 2m-2-2v10a1 1 0 01-1 1h-3m-6 0a1 1 0 001-1v-4a1 1 0 011-1h2a1 1 0 011 1v4a1 1 0 001 1m-6 0h6" } ) ) ), /* @__PURE__ */ React.createElement("div", { className: "max-w-md w-full space-y-6 sm:space-y-8" }, /* @__PURE__ */ React.createElement("div", { className: "text-center" }, /* @__PURE__ */ React.createElement("div", { className: "w-16 h-16 sm:w-20 sm:h-20 md:w-24 md:h-24 mx-auto mb-3 sm:mb-4 md:mb-6 rounded-2xl overflow-hidden shadow-lg" }, /* @__PURE__ */ React.createElement( "img", { src: "https://raw.createusercontent.com/70003f09-f811-4753-8803-75bcd4eab283/", alt: "MTher AI Logo", className: "w-full h-full object-cover" } )), /* @__PURE__ */ React.createElement("h2", { className: "text-xl sm:text-2xl md:text-3xl font-bold text-gray-900 mb-1 sm:mb-2 px-4" }, "Welcome back to MTher AI"), /* @__PURE__ */ React.createElement("p", { className: "text-xs sm:text-sm text-gray-600 px-4" }, "Discover events that match your mood")), /* @__PURE__ */ React.createElement("div", { className: "bg-white rounded-xl sm:rounded-2xl p-5 sm:p-6 md:p-8 shadow-lg border border-gray-200 mx-2 sm:mx-0" }, /* @__PURE__ */ React.createElement( "form", { onSubmit: handleSubmit(onSubmit), className: "space-y-4 sm:space-y-5" }, /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement( "label", { htmlFor: "email", className: "block text-xs sm:text-sm font-medium text-gray-700 mb-1 sm:mb-1.5" }, "Email address" ), /* @__PURE__ */ React.createElement( "input", { ...register("email", { required: "Email is required", pattern: { value: /\S+@\S+\.\S+/, message: "Invalid email address" } }), type: "email", id: "email", className: "w-full px-3 sm:px-4 py-2.5 sm:py-3 md:py-3.5 text-sm sm:text-base border border-gray-300 rounded-lg sm:rounded-xl focus:outline-none focus:ring-2 focus:ring-[#4ECDC4] focus:border-transparent transition-all", placeholder: "Enter your email", disabled: isLoading } ), errors.email && /* @__PURE__ */ React.createElement("p", { className: "text-red-500 text-xs sm:text-sm mt-1 sm:mt-1.5" }, errors.email.message)), /* @__PURE__ */ React.createElement("div", null, /* @__PURE__ */ React.createElement( "label", { htmlFor: "password", className: "block text-xs sm:text-sm font-medium text-gray-700 mb-1 sm:mb-1.5" }, "Password" ), /* @__PURE__ */ React.createElement( "input", { ...register("password", { required: "Password is required", minLength: { value: 6, message: "Password must be at least 6 characters" } }), type: "password", id: "password", className: "w-full px-3 sm:px-4 py-2.5 sm:py-3 md:py-3.5 text-sm sm:text-base border border-gray-300 rounded-lg sm:rounded-xl focus:outline-none focus:ring-2 focus:ring-[#4ECDC4] focus:border-transparent transition-all", placeholder: "Enter your password", disabled: isLoading } ), errors.password && /* @__PURE__ */ React.createElement("p", { className: "text-red-500 text-xs sm:text-sm mt-1 sm:mt-1.5" }, errors.password.message)), error && /* @__PURE__ */ React.createElement("div", { className: "bg-red-50 border border-red-200 text-red-700 px-3 sm:px-4 py-2.5 sm:py-3 rounded-lg sm:rounded-xl text-xs sm:text-sm" }, error), /* @__PURE__ */ React.createElement( "button", { type: "submit", disabled: isLoading, className: "w-full bg-gradient-to-r from-[#FF6B35] to-[#4ECDC4] text-white font-semibold py-2.5 sm:py-3 md:py-3.5 px-6 rounded-lg sm:rounded-xl hover:shadow-lg transition-all duration-200 disabled:opacity-50 disabled:cursor-not-allowed text-sm sm:text-base mt-2" }, isLoading ? /* @__PURE__ */ React.createElement("div", { className: "flex items-center justify-center" }, /* @__PURE__ */ React.createElement("div", { className: "w-4 h-4 sm:w-5 sm:h-5 border-2 border-white border-t-transparent rounded-full animate-spin mr-2" }), /* @__PURE__ */ React.createElement("span", { className: "text-sm sm:text-base" }, "Signing in...")) : "Sign In" ) ), /* @__PURE__ */ React.createElement("div", { className: "mt-5 sm:mt-6 text-center" }, /* @__PURE__ */ React.createElement("p", { className: "text-xs sm:text-sm text-gray-600" }, "Don't have an account?", " ", /* @__PURE__ */ React.createElement( "a", { href: "/account/signup", className: "text-[#4ECDC4] hover:text-[#FF6B35] font-medium transition-colors" }, "Sign up here" )))), /* @__PURE__ */ React.createElement("div", { className: "text-[10px] sm:text-xs text-gray-500 text-center px-4 sm:px-6" }, "By signing in, you agree to our Terms of Service and Privacy Policy"))); } // virtual:/apps/web/src/app/layout.jsx init_injected_globals(); // ../../../node_modules/@tanstack/react-query/build/modern/index.js init_injected_globals(); // ../../../node_modules/@tanstack/query-core/build/modern/index.js init_injected_globals(); // ../../../node_modules/@tanstack/query-core/build/modern/retryer.js init_injected_globals(); // ../../../node_modules/@tanstack/query-core/build/modern/focusManager.js init_injected_globals(); // ../../../node_modules/@tanstack/query-core/build/modern/subscribable.js init_injected_globals(); var Subscribable = class { constructor() { this.listeners = /* @__PURE__ */ new Set(); this.subscribe = this.subscribe.bind(this); } subscribe(listener) { this.listeners.add(listener); this.onSubscribe(); return () => { this.listeners.delete(listener); this.onUnsubscribe(); }; } hasListeners() { return this.listeners.size > 0; } onSubscribe() { } onUnsubscribe() { } }; // ../../../node_modules/@tanstack/query-core/build/modern/utils.js init_injected_globals(); var isServer = typeof window === "undefined" || "Deno" in globalThis; function noop() { } function functionalUpdate(updater, input) { return typeof updater === "function" ? updater(input) : updater; } function isValidTimeout(value) { return typeof value === "number" && value >= 0 && value !== Infinity; } function timeUntilStale(updatedAt, staleTime) { return Math.max(updatedAt + (staleTime || 0) - Date.now(), 0); } function resolveStaleTime(staleTime, query) { return typeof staleTime === "function" ? staleTime(query) : staleTime; } function resolveEnabled(enabled, query) { return typeof enabled === "function" ? enabled(query) : enabled; } function matchQuery(filters, query) { const { type = "all", exact, fetchStatus, predicate, queryKey, stale } = filters; if (queryKey) { if (exact) { if (query.queryHash !== hashQueryKeyByOptions(queryKey, query.options)) { return false; } } else if (!partialMatchKey(query.queryKey, queryKey)) { return false; } } if (type !== "all") { const isActive = query.isActive(); if (type === "active" && !isActive) { return false; } if (type === "inactive" && isActive) { return false; } } if (typeof stale === "boolean" && query.isStale() !== stale) { return false; } if (fetchStatus && fetchStatus !== query.state.fetchStatus) { return false; } if (predicate && !predicate(query)) { return false; } return true; } function matchMutation(filters, mutation) { const { exact, status, predicate, mutationKey } = filters; if (mutationKey) { if (!mutation.options.mutationKey) { return false; } if (exact) { if (hashKey(mutation.options.mutationKey) !== hashKey(mutationKey)) { return false; } } else if (!partialMatchKey(mutation.options.mutationKey, mutationKey)) { return false; } } if (status && mutation.state.status !== status) { return false; } if (predicate && !predicate(mutation)) { return false; } return true; } function hashQueryKeyByOptions(queryKey, options) { const hashFn = options?.queryKeyHashFn || hashKey; return hashFn(queryKey); } function hashKey(queryKey) { return JSON.stringify( queryKey, (_, val) => isPlainObject2(val) ? Object.keys(val).sort().reduce((result, key) => { result[key] = val[key]; return result; }, {}) : val ); } function partialMatchKey(a, b) { if (a === b) { return true; } if (typeof a !== typeof b) { return false; } if (a && b && typeof a === "object" && typeof b === "object") { return Object.keys(b).every((key) => partialMatchKey(a[key], b[key])); } return false; } function replaceEqualDeep(a, b) { if (a === b) { return a; } const array = isPlainArray(a) && isPlainArray(b); if (array || isPlainObject2(a) && isPlainObject2(b)) { const aItems = array ? a : Object.keys(a); const aSize = aItems.length; const bItems = array ? b : Object.keys(b); const bSize = bItems.length; const copy = array ? [] : {}; let equalItems = 0; for (let i = 0; i < bSize; i++) { const key = array ? i : bItems[i]; if ((!array && aItems.includes(key) || array) && a[key] === void 0 && b[key] === void 0) { copy[key] = void 0; equalItems++; } else { copy[key] = replaceEqualDeep(a[key], b[key]); if (copy[key] === a[key] && a[key] !== void 0) { equalItems++; } } } return aSize === bSize && equalItems === aSize ? a : copy; } return b; } function isPlainArray(value) { return Array.isArray(value) && value.length === Object.keys(value).length; } function isPlainObject2(o) { if (!hasObjectPrototype(o)) { return false; } const ctor = o.constructor; if (ctor === void 0) { return true; } const prot = ctor.prototype; if (!hasObjectPrototype(prot)) { return false; } if (!prot.hasOwnProperty("isPrototypeOf")) { return false; } if (Object.getPrototypeOf(o) !== Object.prototype) { return false; } return true; } function hasObjectPrototype(o) { return Object.prototype.toString.call(o) === "[object Object]"; } function sleep(timeout) { return new Promise((resolve) => { setTimeout(resolve, timeout); }); } function replaceData(prevData, data, options) { if (typeof options.structuralSharing === "function") { return options.structuralSharing(prevData, data); } else if (options.structuralSharing !== false) { if (false) { try { return replaceEqualDeep(prevData, data); } catch (error) { console.error( `Structural sharing requires data to be JSON serializable. To fix this, turn off structuralSharing or return JSON-serializable data from your queryFn. [${options.queryHash}]: ${error}` ); throw error; } } return replaceEqualDeep(prevData, data); } return data; } function addToEnd(items, item, max = 0) { const newItems = [...items, item]; return max && newItems.length > max ? newItems.slice(1) : newItems; } function addToStart(items, item, max = 0) { const newItems = [item, ...items]; return max && newItems.length > max ? newItems.slice(0, -1) : newItems; } var skipToken = Symbol(); function ensureQueryFn(options, fetchOptions) { if (false) { if (options.queryFn === skipToken) { console.error( `Attempted to invoke queryFn when set to skipToken. This is likely a configuration error. Query hash: '${options.queryHash}'` ); } } if (!options.queryFn && fetchOptions?.initialPromise) { return () => fetchOptions.initialPromise; } if (!options.queryFn || options.queryFn === skipToken) { return () => Promise.reject(new Error(`Missing queryFn: '${options.queryHash}'`)); } return options.queryFn; } // ../../../node_modules/@tanstack/query-core/build/modern/focusManager.js var FocusManager = class extends Subscribable { #focused; #cleanup; #setup; constructor() { super(); this.#setup = (onFocus) => { if (!isServer && window.addEventListener) { const listener = () => onFocus(); window.addEventListener("visibilitychange", listener, false); return () => { window.removeEventListener("visibilitychange", listener); }; } return; }; } onSubscribe() { if (!this.#cleanup) { this.setEventListener(this.#setup); } } onUnsubscribe() { if (!this.hasListeners()) { this.#cleanup?.(); this.#cleanup = void 0; } } setEventListener(setup) { this.#setup = setup; this.#cleanup?.(); this.#cleanup = setup((focused) => { if (typeof focused === "boolean") { this.setFocused(focused); } else { this.onFocus(); } }); } setFocused(focused) { const changed = this.#focused !== focused; if (changed) { this.#focused = focused; this.onFocus(); } } onFocus() { const isFocused = this.isFocused(); this.listeners.forEach((listener) => { listener(isFocused); }); } isFocused() { if (typeof this.#focused === "boolean") { return this.#focused; } return globalThis.document?.visibilityState !== "hidden"; } }; var focusManager = new FocusManager(); // ../../../node_modules/@tanstack/query-core/build/modern/onlineManager.js init_injected_globals(); var OnlineManager = class extends Subscribable { #online = true; #cleanup; #setup; constructor() { super(); this.#setup = (onOnline) => { if (!isServer && window.addEventListener) { const onlineListener = () => onOnline(true); const offlineListener = () => onOnline(false); window.addEventListener("online", onlineListener, false); window.addEventListener("offline", offlineListener, false); return () => { window.removeEventListener("online", onlineListener); window.removeEventListener("offline", offlineListener); }; } return; }; } onSubscribe() { if (!this.#cleanup) { this.setEventListener(this.#setup); } } onUnsubscribe() { if (!this.hasListeners()) { this.#cleanup?.(); this.#cleanup = void 0; } } setEventListener(setup) { this.#setup = setup; this.#cleanup?.(); this.#cleanup = setup(this.setOnline.bind(this)); } setOnline(online) { const changed = this.#online !== online; if (changed) { this.#online = online; this.listeners.forEach((listener) => { listener(online); }); } } isOnline() { return this.#online; } }; var onlineManager = new OnlineManager(); // ../../../node_modules/@tanstack/query-core/build/modern/thenable.js init_injected_globals(); function pendingThenable() { let resolve; let reject; const thenable = new Promise((_resolve, _reject) => { resolve = _resolve; reject = _reject; }); thenable.status = "pending"; thenable.catch(() => { }); function finalize(data) { Object.assign(thenable, data); delete thenable.resolve; delete thenable.reject; } thenable.resolve = (value) => { finalize({ status: "fulfilled", value }); resolve(value); }; thenable.reject = (reason) => { finalize({ status: "rejected", reason }); reject(reason); }; return thenable; } // ../../../node_modules/@tanstack/query-core/build/modern/retryer.js function defaultRetryDelay(failureCount) { return Math.min(1e3 * 2 ** failureCount, 3e4); } function canFetch(networkMode) { return (networkMode ?? "online") === "online" ? onlineManager.isOnline() : true; } var CancelledError = class extends Error { constructor(options) { super("CancelledError"); this.revert = options?.revert; this.silent = options?.silent; } }; function isCancelledError(value) { return value instanceof CancelledError; } function createRetryer(config) { let isRetryCancelled = false; let failureCount = 0; let isResolved = false; let continueFn; const thenable = pendingThenable(); const cancel = (cancelOptions) => { if (!isResolved) { reject(new CancelledError(cancelOptions)); config.abort?.(); } }; const cancelRetry = () => { isRetryCancelled = true; }; const continueRetry = () => { isRetryCancelled = false; }; const canContinue = () => focusManager.isFocused() && (config.networkMode === "always" || onlineManager.isOnline()) && config.canRun(); const canStart = () => canFetch(config.networkMode) && config.canRun(); const resolve = (value) => { if (!isResolved) { isResolved = true; config.onSuccess?.(value); continueFn?.(); thenable.resolve(value); } }; const reject = (value) => { if (!isResolved) { isResolved = true; config.onError?.(value); continueFn?.(); thenable.reject(value); } }; const pause = () => { return new Promise((continueResolve) => { continueFn = (value) => { if (isResolved || canContinue()) { continueResolve(value); } }; config.onPause?.(); }).then(() => { continueFn = void 0; if (!isResolved) { config.onContinue?.(); } }); }; const run = () => { if (isResolved) { return; } let promiseOrValue; const initialPromise = failureCount === 0 ? config.initialPromise : void 0; try { promiseOrValue = initialPromise ?? config.fn(); } catch (error) { promiseOrValue = Promise.reject(error); } Promise.resolve(promiseOrValue).then(resolve).catch((error) => { if (isResolved) { return; } const retry = config.retry ?? (isServer ? 0 : 3); const retryDelay = config.retryDelay ?? defaultRetryDelay; const delay = typeof retryDelay === "function" ? retryDelay(failureCount, error) : retryDelay; const shouldRetry = retry === true || typeof retry === "number" && failureCount < retry || typeof retry === "function" && retry(failureCount, error); if (isRetryCancelled || !shouldRetry) { reject(error); return; } failureCount++; config.onFail?.(failureCount, error); sleep(delay).then(() => { return canContinue() ? void 0 : pause(); }).then(() => { if (isRetryCancelled) { reject(error); } else { run(); } }); }); }; return { promise: thenable, cancel, continue: () => { continueFn?.(); return thenable; }, cancelRetry, continueRetry, canStart, start: () => { if (canStart()) { run(); } else { pause().then(run); } return thenable; } }; } // ../../../node_modules/@tanstack/query-core/build/modern/queryCache.js init_injected_globals(); // ../../../node_modules/@tanstack/query-core/build/modern/query.js init_injected_globals(); // ../../../node_modules/@tanstack/query-core/build/modern/notifyManager.js init_injected_globals(); var defaultScheduler = (cb) => setTimeout(cb, 0); function createNotifyManager() { let queue = []; let transactions = 0; let notifyFn = (callback) => { callback(); }; let batchNotifyFn = (callback) => { callback(); }; let scheduleFn = defaultScheduler; const schedule = (callback) => { if (transactions) { queue.push(callback); } else { scheduleFn(() => { notifyFn(callback); }); } }; const flush = () => { const originalQueue = queue; queue = []; if (originalQueue.length) { scheduleFn(() => { batchNotifyFn(() => { originalQueue.forEach((callback) => { notifyFn(callback); }); }); }); } }; return { batch: (callback) => { let result; transactions++; try { result = callback(); } finally { transactions--; if (!transactions) { flush(); } } return result; }, /** * All calls to the wrapped function will be batched. */ batchCalls: (callback) => { return (...args) => { schedule(() => { callback(...args); }); }; }, schedule, /** * Use this method to set a custom notify function. * This can be used to for example wrap notifications with `React.act` while running tests. */ setNotifyFunction: (fn) => { notifyFn = fn; }, /** * Use this method to set a custom function to batch notifications together into a single tick. * By default React Query will use the batch function provided by ReactDOM or React Native. */ setBatchNotifyFunction: (fn) => { batchNotifyFn = fn; }, setScheduler: (fn) => { scheduleFn = fn; } }; } var notifyManager = createNotifyManager(); // ../../../node_modules/@tanstack/query-core/build/modern/removable.js init_injected_globals(); var Removable = class { #gcTimeout; destroy() { this.clearGcTimeout(); } scheduleGc() { this.clearGcTimeout(); if (isValidTimeout(this.gcTime)) { this.#gcTimeout = setTimeout(() => { this.optionalRemove(); }, this.gcTime); } } updateGcTime(newGcTime) { this.gcTime = Math.max( this.gcTime || 0, newGcTime ?? (isServer ? Infinity : 5 * 60 * 1e3) ); } clearGcTimeout() { if (this.#gcTimeout) { clearTimeout(this.#gcTimeout); this.#gcTimeout = void 0; } } }; // ../../../node_modules/@tanstack/query-core/build/modern/query.js var Query = class extends Removable { #initialState; #revertState; #cache; #client; #retryer; #defaultOptions; #abortSignalConsumed; constructor(config) { super(); this.#abortSignalConsumed = false; this.#defaultOptions = config.defaultOptions; this.setOptions(config.options); this.observers = []; this.#client = config.client; this.#cache = this.#client.getQueryCache(); this.queryKey = config.queryKey; this.queryHash = config.queryHash; this.#initialState = getDefaultState(this.options); this.state = config.state ?? this.#initialState; this.scheduleGc(); } get meta() { return this.options.meta; } get promise() { return this.#retryer?.promise; } setOptions(options) { this.options = { ...this.#defaultOptions, ...options }; this.updateGcTime(this.options.gcTime); } optionalRemove() { if (!this.observers.length && this.state.fetchStatus === "idle") { this.#cache.remove(this); } } setData(newData, options) { const data = replaceData(this.state.data, newData, this.options); this.#dispatch({ data, type: "success", dataUpdatedAt: options?.updatedAt, manual: options?.manual }); return data; } setState(state, setStateOptions) { this.#dispatch({ type: "setState", state, setStateOptions }); } cancel(options) { const promise = this.#retryer?.promise; this.#retryer?.cancel(options); return promise ? promise.then(noop).catch(noop) : Promise.resolve(); } destroy() { super.destroy(); this.cancel({ silent: true }); } reset() { this.destroy(); this.setState(this.#initialState); } isActive() { return this.observers.some( (observer) => resolveEnabled(observer.options.enabled, this) !== false ); } isDisabled() { if (this.getObserversCount() > 0) { return !this.isActive(); } return this.options.queryFn === skipToken || this.state.dataUpdateCount + this.state.errorUpdateCount === 0; } isStale() { if (this.state.isInvalidated) { return true; } if (this.getObserversCount() > 0) { return this.observers.some( (observer) => observer.getCurrentResult().isStale ); } return this.state.data === void 0; } isStaleByTime(staleTime = 0) { return this.state.isInvalidated || this.state.data === void 0 || !timeUntilStale(this.state.dataUpdatedAt, staleTime); } onFocus() { const observer = this.observers.find((x) => x.shouldFetchOnWindowFocus()); observer?.refetch({ cancelRefetch: false }); this.#retryer?.continue(); } onOnline() { const observer = this.observers.find((x) => x.shouldFetchOnReconnect()); observer?.refetch({ cancelRefetch: false }); this.#retryer?.continue(); } addObserver(observer) { if (!this.observers.includes(observer)) { this.observers.push(observer); this.clearGcTimeout(); this.#cache.notify({ type: "observerAdded", query: this, observer }); } } removeObserver(observer) { if (this.observers.includes(observer)) { this.observers = this.observers.filter((x) => x !== observer); if (!this.observers.length) { if (this.#retryer) { if (this.#abortSignalConsumed) { this.#retryer.cancel({ revert: true }); } else { this.#retryer.cancelRetry(); } } this.scheduleGc(); } this.#cache.notify({ type: "observerRemoved", query: this, observer }); } } getObserversCount() { return this.observers.length; } invalidate() { if (!this.state.isInvalidated) { this.#dispatch({ type: "invalidate" }); } } fetch(options, fetchOptions) { if (this.state.fetchStatus !== "idle") { if (this.state.data !== void 0 && fetchOptions?.cancelRefetch) { this.cancel({ silent: true }); } else if (this.#retryer) { this.#retryer.continueRetry(); return this.#retryer.promise; } } if (options) { this.setOptions(options); } if (!this.options.queryFn) { const observer = this.observers.find((x) => x.options.queryFn); if (observer) { this.setOptions(observer.options); } } if (false) { if (!Array.isArray(this.options.queryKey)) { console.error( `As of v4, queryKey needs to be an Array. If you are using a string like 'repoData', please change it to an Array, e.g. ['repoData']` ); } } const abortController = new AbortController(); const addSignalProperty = (object) => { Object.defineProperty(object, "signal", { enumerable: true, get: () => { this.#abortSignalConsumed = true; return abortController.signal; } }); }; const fetchFn = () => { const queryFn = ensureQueryFn(this.options, fetchOptions); const queryFnContext = { client: this.#client, queryKey: this.queryKey, meta: this.meta }; addSignalProperty(queryFnContext); this.#abortSignalConsumed = false; if (this.options.persister) { return this.options.persister( queryFn, queryFnContext, this ); } return queryFn(queryFnContext); }; const context = { fetchOptions, options: this.options, queryKey: this.queryKey, client: this.#client, state: this.state, fetchFn }; addSignalProperty(context); this.options.behavior?.onFetch( context, this ); this.#revertState = this.state; if (this.state.fetchStatus === "idle" || this.state.fetchMeta !== context.fetchOptions?.meta) { this.#dispatch({ type: "fetch", meta: context.fetchOptions?.meta }); } const onError = (error) => { if (!(isCancelledError(error) && error.silent)) { this.#dispatch({ type: "error", error }); } if (!isCancelledError(error)) { this.#cache.config.onError?.( error, this ); this.#cache.config.onSettled?.( this.state.data, error, this ); } this.scheduleGc(); }; this.#retryer = createRetryer({ initialPromise: fetchOptions?.initialPromise, fn: context.fetchFn, abort: abortController.abort.bind(abortController), onSuccess: (data) => { if (data === void 0) { if (false) { console.error( `Query data cannot be undefined. Please make sure to return a value other than undefined from your query function. Affected query key: ${this.queryHash}` ); } onError(new Error(`${this.queryHash} data is undefined`)); return; } try { this.setData(data); } catch (error) { onError(error); return; } this.#cache.config.onSuccess?.(data, this); this.#cache.config.onSettled?.( data, this.state.error, this ); this.scheduleGc(); }, onError, onFail: (failureCount, error) => { this.#dispatch({ type: "failed", failureCount, error }); }, onPause: () => { this.#dispatch({ type: "pause" }); }, onContinue: () => { this.#dispatch({ type: "continue" }); }, retry: context.options.retry, retryDelay: context.options.retryDelay, networkMode: context.options.networkMode, canRun: () => true }); return this.#retryer.start(); } #dispatch(action) { const reducer = (state) => { switch (action.type) { case "failed": return { ...state, fetchFailureCount: action.failureCount, fetchFailureReason: action.error }; case "pause": return { ...state, fetchStatus: "paused" }; case "continue": return { ...state, fetchStatus: "fetching" }; case "fetch": return { ...state, ...fetchState(state.data, this.options), fetchMeta: action.meta ?? null }; case "success": return { ...state, data: action.data, dataUpdateCount: state.dataUpdateCount + 1, dataUpdatedAt: action.dataUpdatedAt ?? Date.now(), error: null, isInvalidated: false, status: "success", ...!action.manual && { fetchStatus: "idle", fetchFailureCount: 0, fetchFailureReason: null } }; case "error": const error = action.error; if (isCancelledError(error) && error.revert && this.#revertState) { return { ...this.#revertState, fetchStatus: "idle" }; } return { ...state, error, errorUpdateCount: state.errorUpdateCount + 1, errorUpdatedAt: Date.now(), fetchFailureCount: state.fetchFailureCount + 1, fetchFailureReason: error, fetchStatus: "idle", status: "error" }; case "invalidate": return { ...state, isInvalidated: true }; case "setState": return { ...state, ...action.state }; } }; this.state = reducer(this.state); notifyManager.batch(() => { this.observers.forEach((observer) => { observer.onQueryUpdate(); }); this.#cache.notify({ query: this, type: "updated", action }); }); } }; function fetchState(data, options) { return { fetchFailureCount: 0, fetchFailureReason: null, fetchStatus: canFetch(options.networkMode) ? "fetching" : "paused", ...data === void 0 && { error: null, status: "pending" } }; } function getDefaultState(options) { const data = typeof options.initialData === "function" ? options.initialData() : options.initialData; const hasData = data !== void 0; const initialDataUpdatedAt = hasData ? typeof options.initialDataUpdatedAt === "function" ? options.initialDataUpdatedAt() : options.initialDataUpdatedAt : 0; return { data, dataUpdateCount: 0, dataUpdatedAt: hasData ? initialDataUpdatedAt ?? Date.now() : 0, error: null, errorUpdateCount: 0, errorUpdatedAt: 0, fetchFailureCount: 0, fetchFailureReason: null, fetchMeta: null, isInvalidated: false, status: hasData ? "success" : "pending", fetchStatus: "idle" }; } // ../../../node_modules/@tanstack/query-core/build/modern/queryCache.js var QueryCache = class extends Subscribable { constructor(config = {}) { super(); this.config = config; this.#queries = /* @__PURE__ */ new Map(); } #queries; build(client, options, state) { const queryKey = options.queryKey; const queryHash = options.queryHash ?? hashQueryKeyByOptions(queryKey, options); let query = this.get(queryHash); if (!query) { query = new Query({ client, queryKey, queryHash, options: client.defaultQueryOptions(options), state, defaultOptions: client.getQueryDefaults(queryKey) }); this.add(query); } return query; } add(query) { if (!this.#queries.has(query.queryHash)) { this.#queries.set(query.queryHash, query); this.notify({ type: "added", query }); } } remove(query) { const queryInMap = this.#queries.get(query.queryHash); if (queryInMap) { query.destroy(); if (queryInMap === query) { this.#queries.delete(query.queryHash); } this.notify({ type: "removed", query }); } } clear() { notifyManager.batch(() => { this.getAll().forEach((query) => { this.remove(query); }); }); } get(queryHash) { return this.#queries.get(queryHash); } getAll() { return [...this.#queries.values()]; } find(filters) { const defaultedFilters = { exact: true, ...filters }; return this.getAll().find( (query) => matchQuery(defaultedFilters, query) ); } findAll(filters = {}) { const queries = this.getAll(); return Object.keys(filters).length > 0 ? queries.filter((query) => matchQuery(filters, query)) : queries; } notify(event) { notifyManager.batch(() => { this.listeners.forEach((listener) => { listener(event); }); }); } onFocus() { notifyManager.batch(() => { this.getAll().forEach((query) => { query.onFocus(); }); }); } onOnline() { notifyManager.batch(() => { this.getAll().forEach((query) => { query.onOnline(); }); }); } }; // ../../../node_modules/@tanstack/query-core/build/modern/queryClient.js init_injected_globals(); // ../../../node_modules/@tanstack/query-core/build/modern/mutationCache.js init_injected_globals(); // ../../../node_modules/@tanstack/query-core/build/modern/mutation.js init_injected_globals(); var Mutation = class extends Removable { #observers; #mutationCache; #retryer; constructor(config) { super(); this.mutationId = config.mutationId; this.#mutationCache = config.mutationCache; this.#observers = []; this.state = config.state || getDefaultState2(); this.setOptions(config.options); this.scheduleGc(); } setOptions(options) { this.options = options; this.updateGcTime(this.options.gcTime); } get meta() { return this.options.meta; } addObserver(observer) { if (!this.#observers.includes(observer)) { this.#observers.push(observer); this.clearGcTimeout(); this.#mutationCache.notify({ type: "observerAdded", mutation: this, observer }); } } removeObserver(observer) { this.#observers = this.#observers.filter((x) => x !== observer); this.scheduleGc(); this.#mutationCache.notify({ type: "observerRemoved", mutation: this, observer }); } optionalRemove() { if (!this.#observers.length) { if (this.state.status === "pending") { this.scheduleGc(); } else { this.#mutationCache.remove(this); } } } continue() { return this.#retryer?.continue() ?? // continuing a mutation assumes that variables are set, mutation must have been dehydrated before this.execute(this.state.variables); } async execute(variables) { const onContinue = () => { this.#dispatch({ type: "continue" }); }; this.#retryer = createRetryer({ fn: () => { if (!this.options.mutationFn) { return Promise.reject(new Error("No mutationFn found")); } return this.options.mutationFn(variables); }, onFail: (failureCount, error) => { this.#dispatch({ type: "failed", failureCount, error }); }, onPause: () => { this.#dispatch({ type: "pause" }); }, onContinue, retry: this.options.retry ?? 0, retryDelay: this.options.retryDelay, networkMode: this.options.networkMode, canRun: () => this.#mutationCache.canRun(this) }); const restored = this.state.status === "pending"; const isPaused = !this.#retryer.canStart(); try { if (restored) { onContinue(); } else { this.#dispatch({ type: "pending", variables, isPaused }); await this.#mutationCache.config.onMutate?.( variables, this ); const context = await this.options.onMutate?.(variables); if (context !== this.state.context) { this.#dispatch({ type: "pending", context, variables, isPaused }); } } const data = await this.#retryer.start(); await this.#mutationCache.config.onSuccess?.( data, variables, this.state.context, this ); await this.options.onSuccess?.(data, variables, this.state.context); await this.#mutationCache.config.onSettled?.( data, null, this.state.variables, this.state.context, this ); await this.options.onSettled?.(data, null, variables, this.state.context); this.#dispatch({ type: "success", data }); return data; } catch (error) { try { await this.#mutationCache.config.onError?.( error, variables, this.state.context, this ); await this.options.onError?.( error, variables, this.state.context ); await this.#mutationCache.config.onSettled?.( void 0, error, this.state.variables, this.state.context, this ); await this.options.onSettled?.( void 0, error, variables, this.state.context ); throw error; } finally { this.#dispatch({ type: "error", error }); } } finally { this.#mutationCache.runNext(this); } } #dispatch(action) { const reducer = (state) => { switch (action.type) { case "failed": return { ...state, failureCount: action.failureCount, failureReason: action.error }; case "pause": return { ...state, isPaused: true }; case "continue": return { ...state, isPaused: false }; case "pending": return { ...state, context: action.context, data: void 0, failureCount: 0, failureReason: null, error: null, isPaused: action.isPaused, status: "pending", variables: action.variables, submittedAt: Date.now() }; case "success": return { ...state, data: action.data, failureCount: 0, failureReason: null, error: null, status: "success", isPaused: false }; case "error": return { ...state, data: void 0, error: action.error, failureCount: state.failureCount + 1, failureReason: action.error, isPaused: false, status: "error" }; } }; this.state = reducer(this.state); notifyManager.batch(() => { this.#observers.forEach((observer) => { observer.onMutationUpdate(action); }); this.#mutationCache.notify({ mutation: this, type: "updated", action }); }); } }; function getDefaultState2() { return { context: void 0, data: void 0, error: null, failureCount: 0, failureReason: null, isPaused: false, status: "idle", variables: void 0, submittedAt: 0 }; } // ../../../node_modules/@tanstack/query-core/build/modern/mutationCache.js var MutationCache = class extends Subscribable { constructor(config = {}) { super(); this.config = config; this.#mutations = /* @__PURE__ */ new Set(); this.#scopes = /* @__PURE__ */ new Map(); this.#mutationId = 0; } #mutations; #scopes; #mutationId; build(client, options, state) { const mutation = new Mutation({ mutationCache: this, mutationId: ++this.#mutationId, options: client.defaultMutationOptions(options), state }); this.add(mutation); return mutation; } add(mutation) { this.#mutations.add(mutation); const scope = scopeFor(mutation); if (typeof scope === "string") { const scopedMutations = this.#scopes.get(scope); if (scopedMutations) { scopedMutations.push(mutation); } else { this.#scopes.set(scope, [mutation]); } } this.notify({ type: "added", mutation }); } remove(mutation) { if (this.#mutations.delete(mutation)) { const scope = scopeFor(mutation); if (typeof scope === "string") { const scopedMutations = this.#scopes.get(scope); if (scopedMutations) { if (scopedMutations.length > 1) { const index = scopedMutations.indexOf(mutation); if (index !== -1) { scopedMutations.splice(index, 1); } } else if (scopedMutations[0] === mutation) { this.#scopes.delete(scope); } } } } this.notify({ type: "removed", mutation }); } canRun(mutation) { const scope = scopeFor(mutation); if (typeof scope === "string") { const mutationsWithSameScope = this.#scopes.get(scope); const firstPendingMutation = mutationsWithSameScope?.find( (m) => m.state.status === "pending" ); return !firstPendingMutation || firstPendingMutation === mutation; } else { return true; } } runNext(mutation) { const scope = scopeFor(mutation); if (typeof scope === "string") { const foundMutation = this.#scopes.get(scope)?.find((m) => m !== mutation && m.state.isPaused); return foundMutation?.continue() ?? Promise.resolve(); } else { return Promise.resolve(); } } clear() { notifyManager.batch(() => { this.#mutations.forEach((mutation) => { this.notify({ type: "removed", mutation }); }); this.#mutations.clear(); this.#scopes.clear(); }); } getAll() { return Array.from(this.#mutations); } find(filters) { const defaultedFilters = { exact: true, ...filters }; return this.getAll().find( (mutation) => matchMutation(defaultedFilters, mutation) ); } findAll(filters = {}) { return this.getAll().filter((mutation) => matchMutation(filters, mutation)); } notify(event) { notifyManager.batch(() => { this.listeners.forEach((listener) => { listener(event); }); }); } resumePausedMutations() { const pausedMutations = this.getAll().filter((x) => x.state.isPaused); return notifyManager.batch( () => Promise.all( pausedMutations.map((mutation) => mutation.continue().catch(noop)) ) ); } }; function scopeFor(mutation) { return mutation.options.scope?.id; } // ../../../node_modules/@tanstack/query-core/build/modern/infiniteQueryBehavior.js init_injected_globals(); function infiniteQueryBehavior(pages) { return { onFetch: (context, query) => { const options = context.options; const direction = context.fetchOptions?.meta?.fetchMore?.direction; const oldPages = context.state.data?.pages || []; const oldPageParams = context.state.data?.pageParams || []; let result = { pages: [], pageParams: [] }; let currentPage = 0; const fetchFn = async () => { let cancelled = false; const addSignalProperty = (object) => { Object.defineProperty(object, "signal", { enumerable: true, get: () => { if (context.signal.aborted) { cancelled = true; } else { context.signal.addEventListener("abort", () => { cancelled = true; }); } return context.signal; } }); }; const queryFn = ensureQueryFn(context.options, context.fetchOptions); const fetchPage = async (data, param, previous) => { if (cancelled) { return Promise.reject(); } if (param == null && data.pages.length) { return Promise.resolve(data); } const queryFnContext = { client: context.client, queryKey: context.queryKey, pageParam: param, direction: previous ? "backward" : "forward", meta: context.options.meta }; addSignalProperty(queryFnContext); const page = await queryFn( queryFnContext ); const { maxPages } = context.options; const addTo = previous ? addToStart : addToEnd; return { pages: addTo(data.pages, page, maxPages), pageParams: addTo(data.pageParams, param, maxPages) }; }; if (direction && oldPages.length) { const previous = direction === "backward"; const pageParamFn = previous ? getPreviousPageParam : getNextPageParam; const oldData = { pages: oldPages, pageParams: oldPageParams }; const param = pageParamFn(options, oldData); result = await fetchPage(oldData, param, previous); } else { const remainingPages = pages ?? oldPages.length; do { const param = currentPage === 0 ? oldPageParams[0] ?? options.initialPageParam : getNextPageParam(options, result); if (currentPage > 0 && param == null) { break; } result = await fetchPage(result, param); currentPage++; } while (currentPage < remainingPages); } return result; }; if (context.options.persister) { context.fetchFn = () => { return context.options.persister?.( fetchFn, { client: context.client, queryKey: context.queryKey, meta: context.options.meta, signal: context.signal }, query ); }; } else { context.fetchFn = fetchFn; } } }; } function getNextPageParam(options, { pages, pageParams }) { const lastIndex = pages.length - 1; return pages.length > 0 ? options.getNextPageParam( pages[lastIndex], pages, pageParams[lastIndex], pageParams ) : void 0; } function getPreviousPageParam(options, { pages, pageParams }) { return pages.length > 0 ? options.getPreviousPageParam?.(pages[0], pages, pageParams[0], pageParams) : void 0; } // ../../../node_modules/@tanstack/query-core/build/modern/queryClient.js var QueryClient = class { #queryCache; #mutationCache; #defaultOptions; #queryDefaults; #mutationDefaults; #mountCount; #unsubscribeFocus; #unsubscribeOnline; constructor(config = {}) { this.#queryCache = config.queryCache || new QueryCache(); this.#mutationCache = config.mutationCache || new MutationCache(); this.#defaultOptions = config.defaultOptions || {}; this.#queryDefaults = /* @__PURE__ */ new Map(); this.#mutationDefaults = /* @__PURE__ */ new Map(); this.#mountCount = 0; } mount() { this.#mountCount++; if (this.#mountCount !== 1) return; this.#unsubscribeFocus = focusManager.subscribe(async (focused) => { if (focused) { await this.resumePausedMutations(); this.#queryCache.onFocus(); } }); this.#unsubscribeOnline = onlineManager.subscribe(async (online) => { if (online) { await this.resumePausedMutations(); this.#queryCache.onOnline(); } }); } unmount() { this.#mountCount--; if (this.#mountCount !== 0) return; this.#unsubscribeFocus?.(); this.#unsubscribeFocus = void 0; this.#unsubscribeOnline?.(); this.#unsubscribeOnline = void 0; } isFetching(filters) { return this.#queryCache.findAll({ ...filters, fetchStatus: "fetching" }).length; } isMutating(filters) { return this.#mutationCache.findAll({ ...filters, status: "pending" }).length; } /** * Imperative (non-reactive) way to retrieve data for a QueryKey. * Should only be used in callbacks or functions where reading the latest data is necessary, e.g. for optimistic updates. * * Hint: Do not use this function inside a component, because it won't receive updates. * Use `useQuery` to create a `QueryObserver` that subscribes to changes. */ getQueryData(queryKey) { const options = this.defaultQueryOptions({ queryKey }); return this.#queryCache.get(options.queryHash)?.state.data; } ensureQueryData(options) { const defaultedOptions = this.defaultQueryOptions(options); const query = this.#queryCache.build(this, defaultedOptions); const cachedData = query.state.data; if (cachedData === void 0) { return this.fetchQuery(options); } if (options.revalidateIfStale && query.isStaleByTime(resolveStaleTime(defaultedOptions.staleTime, query))) { void this.prefetchQuery(defaultedOptions); } return Promise.resolve(cachedData); } getQueriesData(filters) { return this.#queryCache.findAll(filters).map(({ queryKey, state }) => { const data = state.data; return [queryKey, data]; }); } setQueryData(queryKey, updater, options) { const defaultedOptions = this.defaultQueryOptions({ queryKey }); const query = this.#queryCache.get( defaultedOptions.queryHash ); const prevData = query?.state.data; const data = functionalUpdate(updater, prevData); if (data === void 0) { return void 0; } return this.#queryCache.build(this, defaultedOptions).setData(data, { ...options, manual: true }); } setQueriesData(filters, updater, options) { return notifyManager.batch( () => this.#queryCache.findAll(filters).map(({ queryKey }) => [ queryKey, this.setQueryData(queryKey, updater, options) ]) ); } getQueryState(queryKey) { const options = this.defaultQueryOptions({ queryKey }); return this.#queryCache.get( options.queryHash )?.state; } removeQueries(filters) { const queryCache = this.#queryCache; notifyManager.batch(() => { queryCache.findAll(filters).forEach((query) => { queryCache.remove(query); }); }); } resetQueries(filters, options) { const queryCache = this.#queryCache; return notifyManager.batch(() => { queryCache.findAll(filters).forEach((query) => { query.reset(); }); return this.refetchQueries( { type: "active", ...filters }, options ); }); } cancelQueries(filters, cancelOptions = {}) { const defaultedCancelOptions = { revert: true, ...cancelOptions }; const promises = notifyManager.batch( () => this.#queryCache.findAll(filters).map((query) => query.cancel(defaultedCancelOptions)) ); return Promise.all(promises).then(noop).catch(noop); } invalidateQueries(filters, options = {}) { return notifyManager.batch(() => { this.#queryCache.findAll(filters).forEach((query) => { query.invalidate(); }); if (filters?.refetchType === "none") { return Promise.resolve(); } return this.refetchQueries( { ...filters, type: filters?.refetchType ?? filters?.type ?? "active" }, options ); }); } refetchQueries(filters, options = {}) { const fetchOptions = { ...options, cancelRefetch: options.cancelRefetch ?? true }; const promises = notifyManager.batch( () => this.#queryCache.findAll(filters).filter((query) => !query.isDisabled()).map((query) => { let promise = query.fetch(void 0, fetchOptions); if (!fetchOptions.throwOnError) { promise = promise.catch(noop); } return query.state.fetchStatus === "paused" ? Promise.resolve() : promise; }) ); return Promise.all(promises).then(noop); } fetchQuery(options) { const defaultedOptions = this.defaultQueryOptions(options); if (defaultedOptions.retry === void 0) { defaultedOptions.retry = false; } const query = this.#queryCache.build(this, defaultedOptions); return query.isStaleByTime( resolveStaleTime(defaultedOptions.staleTime, query) ) ? query.fetch(defaultedOptions) : Promise.resolve(query.state.data); } prefetchQuery(options) { return this.fetchQuery(options).then(noop).catch(noop); } fetchInfiniteQuery(options) { options.behavior = infiniteQueryBehavior(options.pages); return this.fetchQuery(options); } prefetchInfiniteQuery(options) { return this.fetchInfiniteQuery(options).then(noop).catch(noop); } ensureInfiniteQueryData(options) { options.behavior = infiniteQueryBehavior(options.pages); return this.ensureQueryData(options); } resumePausedMutations() { if (onlineManager.isOnline()) { return this.#mutationCache.resumePausedMutations(); } return Promise.resolve(); } getQueryCache() { return this.#queryCache; } getMutationCache() { return this.#mutationCache; } getDefaultOptions() { return this.#defaultOptions; } setDefaultOptions(options) { this.#defaultOptions = options; } setQueryDefaults(queryKey, options) { this.#queryDefaults.set(hashKey(queryKey), { queryKey, defaultOptions: options }); } getQueryDefaults(queryKey) { const defaults = [...this.#queryDefaults.values()]; const result = {}; defaults.forEach((queryDefault) => { if (partialMatchKey(queryKey, queryDefault.queryKey)) { Object.assign(result, queryDefault.defaultOptions); } }); return result; } setMutationDefaults(mutationKey, options) { this.#mutationDefaults.set(hashKey(mutationKey), { mutationKey, defaultOptions: options }); } getMutationDefaults(mutationKey) { const defaults = [...this.#mutationDefaults.values()]; const result = {}; defaults.forEach((queryDefault) => { if (partialMatchKey(mutationKey, queryDefault.mutationKey)) { Object.assign(result, queryDefault.defaultOptions); } }); return result; } defaultQueryOptions(options) { if (options._defaulted) { return options; } const defaultedOptions = { ...this.#defaultOptions.queries, ...this.getQueryDefaults(options.queryKey), ...options, _defaulted: true }; if (!defaultedOptions.queryHash) { defaultedOptions.queryHash = hashQueryKeyByOptions( defaultedOptions.queryKey, defaultedOptions ); } if (defaultedOptions.refetchOnReconnect === void 0) { defaultedOptions.refetchOnReconnect = defaultedOptions.networkMode !== "always"; } if (defaultedOptions.throwOnError === void 0) { defaultedOptions.throwOnError = !!defaultedOptions.suspense; } if (!defaultedOptions.networkMode && defaultedOptions.persister) { defaultedOptions.networkMode = "offlineFirst"; } if (defaultedOptions.queryFn === skipToken) { defaultedOptions.enabled = false; } return defaultedOptions; } defaultMutationOptions(options) { if (options?._defaulted) { return options; } return { ...this.#defaultOptions.mutations, ...options?.mutationKey && this.getMutationDefaults(options.mutationKey), ...options, _defaulted: true }; } clear() { this.#queryCache.clear(); this.#mutationCache.clear(); } }; // ../../../node_modules/@tanstack/react-query/build/modern/QueryClientProvider.js init_injected_globals(); var React3 = __toESM(require_react(), 1); var import_jsx_runtime = __toESM(require_jsx_runtime(), 1); var QueryClientContext = React3.createContext( void 0 ); var QueryClientProvider = ({ client, children }) => { React3.useEffect(() => { client.mount(); return () => { client.unmount(); }; }, [client]); return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(QueryClientContext.Provider, { value: client, children }); }; // virtual:/apps/web/src/app/layout.jsx var import_react5 = __toESM(require_react()); function RootLayout({ children }) { const [queryClient] = (0, import_react5.useState)( () => new QueryClient({ defaultOptions: { queries: { staleTime: 1e3 * 60 * 5, // 5 minutes gcTime: 1e3 * 60 * 30, // 30 minutes (replaces cacheTime) retry: 1, refetchOnWindowFocus: false } } }) ); return /* @__PURE__ */ React.createElement("html", { lang: "en" }, /* @__PURE__ */ React.createElement("head", null, /* @__PURE__ */ React.createElement("meta", { charSet: "utf-8" }), /* @__PURE__ */ React.createElement("meta", { name: "viewport", content: "width=device-width, initial-scale=1" }), /* @__PURE__ */ React.createElement("title", null, "MTher AI - Find Events That Match Your Mood"), /* @__PURE__ */ React.createElement( "meta", { name: "description", content: "Discover events and activities based on how you feel. AI-powered mood analysis finds the perfect experiences for you." } )), /* @__PURE__ */ React.createElement("body", null, /* @__PURE__ */ React.createElement(QueryClientProvider, { client: queryClient }, children))); } // virtual:/__wrapped_entry__.jsx function WrappedPage(props) { let content = /* @__PURE__ */ import_react6.default.createElement(SignIn, { ...props }); content = /* @__PURE__ */ import_react6.default.createElement(RootLayout, null, content); return content; } return __toCommonJS(wrapped_entry_exports); })(); /*! Bundled license information: react/cjs/react-jsx-runtime.production.min.js: (** * @license React * react-jsx-runtime.production.min.js * * Copyright (c) Facebook, Inc. and its affiliates. * * This source code is licensed under the MIT license found in the * LICENSE file in the root directory of this source tree. *) */