import "/_nuxt/node_modules/.cache/vite/client/deps/chunk-V4OQ3NZ2.js?v=e4f18c29";
// node_modules/vee-validate/dist/vee-validate.esm.js
import { getCurrentInstance, inject, warn as warn$1, ref, unref, computed, reactive, watch, onUnmounted, nextTick, onMounted, provide, isRef, onBeforeUnmount, defineComponent, toRef, resolveDynamicComponent, h, watchEffect, markRaw } from "/_nuxt/node_modules/vue/dist/vue.runtime.esm-bundler.js?v=e4f18c29";
import { setupDevtoolsPlugin } from "/_nuxt/node_modules/@vue/devtools-api/lib/esm/index.js?v=e4f18c29";
function isCallable(fn) {
return typeof fn === "function";
}
function isNullOrUndefined(value) {
return value === null || value === void 0;
}
var isObject = (obj) => obj !== null && !!obj && typeof obj === "object" && !Array.isArray(obj);
function isIndex(value) {
return Number(value) >= 0;
}
function toNumber(value) {
const n = parseFloat(value);
return isNaN(n) ? value : n;
}
var RULES = {};
function defineRule(id, validator) {
guardExtend(id, validator);
RULES[id] = validator;
}
function resolveRule(id) {
return RULES[id];
}
function guardExtend(id, validator) {
if (isCallable(validator)) {
return;
}
throw new Error(`Extension Error: The validator '${id}' must be a function.`);
}
var FormContextKey = Symbol("vee-validate-form");
var FieldContextKey = Symbol("vee-validate-field-instance");
var IS_ABSENT = Symbol("Default empty value");
var isClient = typeof window !== "undefined";
function isLocator(value) {
return isCallable(value) && !!value.__locatorRef;
}
function isYupValidator(value) {
return !!value && isCallable(value.validate);
}
function hasCheckedAttr(type) {
return type === "checkbox" || type === "radio";
}
function isContainerValue(value) {
return isObject(value) || Array.isArray(value);
}
function isEmptyContainer(value) {
if (Array.isArray(value)) {
return value.length === 0;
}
return isObject(value) && Object.keys(value).length === 0;
}
function isNotNestedPath(path) {
return /^\[.+\]$/i.test(path);
}
function isNativeMultiSelect(el) {
return isNativeSelect(el) && el.multiple;
}
function isNativeSelect(el) {
return el.tagName === "SELECT";
}
function isNativeMultiSelectNode(tag, attrs) {
const hasTruthyBindingValue = ![false, null, void 0, 0].includes(attrs.multiple) && !Number.isNaN(attrs.multiple);
return tag === "select" && "multiple" in attrs && hasTruthyBindingValue;
}
function shouldHaveValueBinding(tag, attrs) {
return !isNativeMultiSelectNode(tag, attrs) && attrs.type !== "file" && !hasCheckedAttr(attrs.type);
}
function isFormSubmitEvent(evt) {
return isEvent(evt) && evt.target && "submit" in evt.target;
}
function isEvent(evt) {
if (!evt) {
return false;
}
if (typeof Event !== "undefined" && isCallable(Event) && evt instanceof Event) {
return true;
}
if (evt && evt.srcElement) {
return true;
}
return false;
}
function isPropPresent(obj, prop) {
return prop in obj && obj[prop] !== IS_ABSENT;
}
function isEqual(a, b) {
if (a === b)
return true;
if (a && b && typeof a === "object" && typeof b === "object") {
if (a.constructor !== b.constructor)
return false;
var length, i, keys;
if (Array.isArray(a)) {
length = a.length;
if (length != b.length)
return false;
for (i = length; i-- !== 0; )
if (!isEqual(a[i], b[i]))
return false;
return true;
}
if (a instanceof Map && b instanceof Map) {
if (a.size !== b.size)
return false;
for (i of a.entries())
if (!b.has(i[0]))
return false;
for (i of a.entries())
if (!isEqual(i[1], b.get(i[0])))
return false;
return true;
}
if (isFile(a) && isFile(b)) {
if (a.size !== b.size)
return false;
if (a.name !== b.name)
return false;
if (a.lastModified !== b.lastModified)
return false;
if (a.type !== b.type)
return false;
return true;
}
if (a instanceof Set && b instanceof Set) {
if (a.size !== b.size)
return false;
for (i of a.entries())
if (!b.has(i[0]))
return false;
return true;
}
if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
length = a.length;
if (length != b.length)
return false;
for (i = length; i-- !== 0; )
if (a[i] !== b[i])
return false;
return true;
}
if (a.constructor === RegExp)
return a.source === b.source && a.flags === b.flags;
if (a.valueOf !== Object.prototype.valueOf)
return a.valueOf() === b.valueOf();
if (a.toString !== Object.prototype.toString)
return a.toString() === b.toString();
keys = Object.keys(a);
length = keys.length;
if (length !== Object.keys(b).length)
return false;
for (i = length; i-- !== 0; )
if (!Object.prototype.hasOwnProperty.call(b, keys[i]))
return false;
for (i = length; i-- !== 0; ) {
var key = keys[i];
if (!isEqual(a[key], b[key]))
return false;
}
return true;
}
return a !== a && b !== b;
}
function isFile(a) {
if (!isClient) {
return false;
}
return a instanceof File;
}
var fastDeepEqual = function equal(a, b) {
if (a === b) return true;
if (a && b && typeof a == "object" && typeof b == "object") {
if (a.constructor !== b.constructor) return false;
var length, i, keys;
if (Array.isArray(a)) {
length = a.length;
if (length != b.length) return false;
for (i = length; i-- !== 0; )
if (!equal(a[i], b[i])) return false;
return true;
}
if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
keys = Object.keys(a);
length = keys.length;
if (length !== Object.keys(b).length) return false;
for (i = length; i-- !== 0; )
if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
for (i = length; i-- !== 0; ) {
var key = keys[i];
if (!equal(a[key], b[key])) return false;
}
return true;
}
return a !== a && b !== b;
};
function cleanupNonNestedPath(path) {
if (isNotNestedPath(path)) {
return path.replace(/\[|\]/gi, "");
}
return path;
}
function getFromPath(object, path, fallback) {
if (!object) {
return fallback;
}
if (isNotNestedPath(path)) {
return object[cleanupNonNestedPath(path)];
}
const resolvedValue = (path || "").split(/\.|\[(\d+)\]/).filter(Boolean).reduce((acc, propKey) => {
if (isContainerValue(acc) && propKey in acc) {
return acc[propKey];
}
return fallback;
}, object);
return resolvedValue;
}
function setInPath(object, path, value) {
if (isNotNestedPath(path)) {
object[cleanupNonNestedPath(path)] = value;
return;
}
const keys = path.split(/\.|\[(\d+)\]/).filter(Boolean);
let acc = object;
for (let i = 0; i < keys.length; i++) {
if (i === keys.length - 1) {
acc[keys[i]] = value;
return;
}
if (!(keys[i] in acc) || isNullOrUndefined(acc[keys[i]])) {
acc[keys[i]] = isIndex(keys[i + 1]) ? [] : {};
}
acc = acc[keys[i]];
}
}
function unset(object, key) {
if (Array.isArray(object) && isIndex(key)) {
object.splice(Number(key), 1);
return;
}
if (isObject(object)) {
delete object[key];
}
}
function unsetPath(object, path) {
if (isNotNestedPath(path)) {
delete object[cleanupNonNestedPath(path)];
return;
}
const keys = path.split(/\.|\[(\d+)\]/).filter(Boolean);
let acc = object;
for (let i = 0; i < keys.length; i++) {
if (i === keys.length - 1) {
unset(acc, keys[i]);
break;
}
if (!(keys[i] in acc) || isNullOrUndefined(acc[keys[i]])) {
break;
}
acc = acc[keys[i]];
}
const pathValues = keys.map((_, idx) => {
return getFromPath(object, keys.slice(0, idx).join("."));
});
for (let i = pathValues.length - 1; i >= 0; i--) {
if (!isEmptyContainer(pathValues[i])) {
continue;
}
if (i === 0) {
unset(object, keys[0]);
continue;
}
unset(pathValues[i - 1], keys[i - 1]);
}
}
function keysOf(record) {
return Object.keys(record);
}
function injectWithSelf(symbol, def = void 0) {
const vm = getCurrentInstance();
return (vm === null || vm === void 0 ? void 0 : vm.provides[symbol]) || inject(symbol, def);
}
function warn(message) {
warn$1(`[vee-validate]: ${message}`);
}
function normalizeField(field) {
if (Array.isArray(field)) {
return field[0];
}
return field;
}
function resolveNextCheckboxValue(currentValue, checkedValue, uncheckedValue) {
if (Array.isArray(currentValue)) {
const newVal = [...currentValue];
const idx = newVal.findIndex((v) => fastDeepEqual(v, checkedValue));
idx >= 0 ? newVal.splice(idx, 1) : newVal.push(checkedValue);
return newVal;
}
return fastDeepEqual(currentValue, checkedValue) ? uncheckedValue : checkedValue;
}
function throttle(func, limit) {
let inThrottle;
let lastResult;
return function(...args) {
const context = this;
if (!inThrottle) {
inThrottle = true;
setTimeout(() => inThrottle = false, limit);
lastResult = func.apply(context, args);
}
return lastResult;
};
}
function debounceAsync(inner, ms = 0) {
let timer = null;
let resolves = [];
return function(...args) {
if (timer) {
window.clearTimeout(timer);
}
timer = window.setTimeout(() => {
const result = inner(...args);
resolves.forEach((r) => r(result));
resolves = [];
}, ms);
return new Promise((resolve) => resolves.push(resolve));
};
}
function applyModelModifiers(value, modifiers) {
if (!isObject(modifiers)) {
return value;
}
if (modifiers.number) {
return toNumber(value);
}
return value;
}
function withLatest(fn, onDone) {
let latestRun;
return async function runLatest(...args) {
const pending = fn(...args);
latestRun = pending;
const result = await pending;
if (pending !== latestRun) {
return result;
}
latestRun = void 0;
onDone(result, args);
return result;
};
}
var normalizeChildren = (tag, context, slotProps) => {
if (!context.slots.default) {
return context.slots.default;
}
if (typeof tag === "string" || !tag) {
return context.slots.default(slotProps());
}
return {
default: () => {
var _a, _b;
return (_b = (_a = context.slots).default) === null || _b === void 0 ? void 0 : _b.call(_a, slotProps());
}
};
};
function getBoundValue(el) {
if (hasValueBinding(el)) {
return el._value;
}
return void 0;
}
function hasValueBinding(el) {
return "_value" in el;
}
function normalizeEventValue(value) {
if (!isEvent(value)) {
return value;
}
const input = value.target;
if (hasCheckedAttr(input.type) && hasValueBinding(input)) {
return getBoundValue(input);
}
if (input.type === "file" && input.files) {
const files = Array.from(input.files);
return input.multiple ? files : files[0];
}
if (isNativeMultiSelect(input)) {
return Array.from(input.options).filter((opt) => opt.selected && !opt.disabled).map(getBoundValue);
}
if (isNativeSelect(input)) {
const selectedOption = Array.from(input.options).find((opt) => opt.selected);
return selectedOption ? getBoundValue(selectedOption) : input.value;
}
return input.value;
}
function normalizeRules(rules) {
const acc = {};
Object.defineProperty(acc, "_$$isNormalized", {
value: true,
writable: false,
enumerable: false,
configurable: false
});
if (!rules) {
return acc;
}
if (isObject(rules) && rules._$$isNormalized) {
return rules;
}
if (isObject(rules)) {
return Object.keys(rules).reduce((prev, curr) => {
const params = normalizeParams(rules[curr]);
if (rules[curr] !== false) {
prev[curr] = buildParams(params);
}
return prev;
}, acc);
}
if (typeof rules !== "string") {
return acc;
}
return rules.split("|").reduce((prev, rule) => {
const parsedRule = parseRule(rule);
if (!parsedRule.name) {
return prev;
}
prev[parsedRule.name] = buildParams(parsedRule.params);
return prev;
}, acc);
}
function normalizeParams(params) {
if (params === true) {
return [];
}
if (Array.isArray(params)) {
return params;
}
if (isObject(params)) {
return params;
}
return [params];
}
function buildParams(provided) {
const mapValueToLocator = (value) => {
if (typeof value === "string" && value[0] === "@") {
return createLocator(value.slice(1));
}
return value;
};
if (Array.isArray(provided)) {
return provided.map(mapValueToLocator);
}
if (provided instanceof RegExp) {
return [provided];
}
return Object.keys(provided).reduce((prev, key) => {
prev[key] = mapValueToLocator(provided[key]);
return prev;
}, {});
}
var parseRule = (rule) => {
let params = [];
const name = rule.split(":")[0];
if (rule.includes(":")) {
params = rule.split(":").slice(1).join(":").split(",");
}
return { name, params };
};
function createLocator(value) {
const locator = (crossTable) => {
const val = getFromPath(crossTable, value) || crossTable[value];
return val;
};
locator.__locatorRef = value;
return locator;
}
function extractLocators(params) {
if (Array.isArray(params)) {
return params.filter(isLocator);
}
return keysOf(params).filter((key) => isLocator(params[key])).map((key) => params[key]);
}
var DEFAULT_CONFIG = {
generateMessage: ({ field }) => `${field} is not valid.`,
bails: true,
validateOnBlur: true,
validateOnChange: true,
validateOnInput: false,
validateOnModelUpdate: true
};
var currentConfig = Object.assign({}, DEFAULT_CONFIG);
var getConfig = () => currentConfig;
var setConfig = (newConf) => {
currentConfig = Object.assign(Object.assign({}, currentConfig), newConf);
};
var configure = setConfig;
async function validate(value, rules, options = {}) {
const shouldBail = options === null || options === void 0 ? void 0 : options.bails;
const field = {
name: (options === null || options === void 0 ? void 0 : options.name) || "{field}",
rules,
bails: shouldBail !== null && shouldBail !== void 0 ? shouldBail : true,
formData: (options === null || options === void 0 ? void 0 : options.values) || {}
};
const result = await _validate(field, value);
const errors = result.errors;
return {
errors,
valid: !errors.length
};
}
async function _validate(field, value) {
if (isYupValidator(field.rules)) {
return validateFieldWithYup(value, field.rules, { bails: field.bails });
}
if (isCallable(field.rules) || Array.isArray(field.rules)) {
const ctx = {
field: field.name,
form: field.formData,
value
};
const pipeline = Array.isArray(field.rules) ? field.rules : [field.rules];
const length2 = pipeline.length;
const errors2 = [];
for (let i = 0; i < length2; i++) {
const rule = pipeline[i];
const result = await rule(value, ctx);
const isValid = typeof result !== "string" && result;
if (isValid) {
continue;
}
const message = typeof result === "string" ? result : _generateFieldError(ctx);
errors2.push(message);
if (field.bails) {
return {
errors: errors2
};
}
}
return {
errors: errors2
};
}
const normalizedContext = Object.assign(Object.assign({}, field), { rules: normalizeRules(field.rules) });
const errors = [];
const rulesKeys = Object.keys(normalizedContext.rules);
const length = rulesKeys.length;
for (let i = 0; i < length; i++) {
const rule = rulesKeys[i];
const result = await _test(normalizedContext, value, {
name: rule,
params: normalizedContext.rules[rule]
});
if (result.error) {
errors.push(result.error);
if (field.bails) {
return {
errors
};
}
}
}
return {
errors
};
}
async function validateFieldWithYup(value, validator, opts) {
var _a;
const errors = await validator.validate(value, {
abortEarly: (_a = opts.bails) !== null && _a !== void 0 ? _a : true
}).then(() => []).catch((err) => {
if (err.name === "ValidationError") {
return err.errors;
}
throw err;
});
return {
errors
};
}
async function _test(field, value, rule) {
const validator = resolveRule(rule.name);
if (!validator) {
throw new Error(`No such validator '${rule.name}' exists.`);
}
const params = fillTargetValues(rule.params, field.formData);
const ctx = {
field: field.name,
value,
form: field.formData,
rule: Object.assign(Object.assign({}, rule), { params })
};
const result = await validator(value, params, ctx);
if (typeof result === "string") {
return {
error: result
};
}
return {
error: result ? void 0 : _generateFieldError(ctx)
};
}
function _generateFieldError(fieldCtx) {
const message = getConfig().generateMessage;
if (!message) {
return "Field is invalid";
}
return message(fieldCtx);
}
function fillTargetValues(params, crossTable) {
const normalize = (value) => {
if (isLocator(value)) {
return value(crossTable);
}
return value;
};
if (Array.isArray(params)) {
return params.map(normalize);
}
return Object.keys(params).reduce((acc, param) => {
acc[param] = normalize(params[param]);
return acc;
}, {});
}
async function validateYupSchema(schema, values) {
const errorObjects = await schema.validate(values, { abortEarly: false }).then(() => []).catch((err) => {
if (err.name !== "ValidationError") {
throw err;
}
return err.inner || [];
});
const results = {};
const errors = {};
for (const error of errorObjects) {
const messages = error.errors;
results[error.path] = { valid: !messages.length, errors: messages };
if (messages.length) {
errors[error.path] = messages[0];
}
}
return {
valid: !errorObjects.length,
results,
errors
};
}
async function validateObjectSchema(schema, values, opts) {
const paths = keysOf(schema);
const validations = paths.map(async (path) => {
var _a, _b, _c;
const fieldResult = await validate(getFromPath(values, path), schema[path], {
name: ((_a = opts === null || opts === void 0 ? void 0 : opts.names) === null || _a === void 0 ? void 0 : _a[path]) || path,
values,
bails: (_c = (_b = opts === null || opts === void 0 ? void 0 : opts.bailsMap) === null || _b === void 0 ? void 0 : _b[path]) !== null && _c !== void 0 ? _c : true
});
return Object.assign(Object.assign({}, fieldResult), { path });
});
let isAllValid = true;
const validationResults = await Promise.all(validations);
const results = {};
const errors = {};
for (const result of validationResults) {
results[result.path] = {
valid: result.valid,
errors: result.errors
};
if (!result.valid) {
isAllValid = false;
errors[result.path] = result.errors[0];
}
}
return {
valid: isAllValid,
results,
errors
};
}
function set(obj, key, val) {
if (typeof val.value === "object") val.value = klona(val.value);
if (!val.enumerable || val.get || val.set || !val.configurable || !val.writable || key === "__proto__") {
Object.defineProperty(obj, key, val);
} else obj[key] = val.value;
}
function klona(x) {
if (typeof x !== "object") return x;
var i = 0, k, list, tmp, str = Object.prototype.toString.call(x);
if (str === "[object Object]") {
tmp = Object.create(x.__proto__ || null);
} else if (str === "[object Array]") {
tmp = Array(x.length);
} else if (str === "[object Set]") {
tmp = /* @__PURE__ */ new Set();
x.forEach(function(val) {
tmp.add(klona(val));
});
} else if (str === "[object Map]") {
tmp = /* @__PURE__ */ new Map();
x.forEach(function(val, key) {
tmp.set(klona(key), klona(val));
});
} else if (str === "[object Date]") {
tmp = /* @__PURE__ */ new Date(+x);
} else if (str === "[object RegExp]") {
tmp = new RegExp(x.source, x.flags);
} else if (str === "[object DataView]") {
tmp = new x.constructor(klona(x.buffer));
} else if (str === "[object ArrayBuffer]") {
tmp = x.slice(0);
} else if (str.slice(-6) === "Array]") {
tmp = new x.constructor(x);
}
if (tmp) {
for (list = Object.getOwnPropertySymbols(x); i < list.length; i++) {
set(tmp, list[i], Object.getOwnPropertyDescriptor(x, list[i]));
}
for (i = 0, list = Object.getOwnPropertyNames(x); i < list.length; i++) {
if (Object.hasOwnProperty.call(tmp, k = list[i]) && tmp[k] === x[k]) continue;
set(tmp, k, Object.getOwnPropertyDescriptor(x, k));
}
}
return tmp || x;
}
var ID_COUNTER = 0;
function useFieldState(path, init) {
const { value, initialValue, setInitialValue } = _useFieldValue(path, init.modelValue, init.form);
const { errorMessage, errors, setErrors } = _useFieldErrors(path, init.form);
const meta = _useFieldMeta(value, initialValue, errors);
const id = ID_COUNTER >= Number.MAX_SAFE_INTEGER ? 0 : ++ID_COUNTER;
function setState(state) {
var _a;
if ("value" in state) {
value.value = state.value;
}
if ("errors" in state) {
setErrors(state.errors);
}
if ("touched" in state) {
meta.touched = (_a = state.touched) !== null && _a !== void 0 ? _a : meta.touched;
}
if ("initialValue" in state) {
setInitialValue(state.initialValue);
}
}
return {
id,
path,
value,
initialValue,
meta,
errors,
errorMessage,
setState
};
}
function _useFieldValue(path, modelValue, form) {
const modelRef = ref(unref(modelValue));
function resolveInitialValue2() {
if (!form) {
return unref(modelRef);
}
return getFromPath(form.meta.value.initialValues, unref(path), unref(modelRef));
}
function setInitialValue(value2) {
if (!form) {
modelRef.value = value2;
return;
}
form.stageInitialValue(unref(path), value2, true);
}
const initialValue = computed(resolveInitialValue2);
if (!form) {
const value2 = ref(resolveInitialValue2());
return {
value: value2,
initialValue,
setInitialValue
};
}
const currentValue = modelValue ? unref(modelValue) : getFromPath(form.values, unref(path), unref(initialValue));
form.stageInitialValue(unref(path), currentValue, true);
const value = computed({
get() {
return getFromPath(form.values, unref(path));
},
set(newVal) {
form.setFieldValue(unref(path), newVal);
}
});
return {
value,
initialValue,
setInitialValue
};
}
function _useFieldMeta(currentValue, initialValue, errors) {
const meta = reactive({
touched: false,
pending: false,
valid: true,
validated: !!unref(errors).length,
initialValue: computed(() => unref(initialValue)),
dirty: computed(() => {
return !isEqual(unref(currentValue), unref(initialValue));
})
});
watch(errors, (value) => {
meta.valid = !value.length;
}, {
immediate: true,
flush: "sync"
});
return meta;
}
function _useFieldErrors(path, form) {
function normalizeErrors(messages) {
if (!messages) {
return [];
}
return Array.isArray(messages) ? messages : [messages];
}
if (!form) {
const errors2 = ref([]);
return {
errors: errors2,
errorMessage: computed(() => errors2.value[0]),
setErrors: (messages) => {
errors2.value = normalizeErrors(messages);
}
};
}
const errors = computed(() => form.errorBag.value[unref(path)] || []);
return {
errors,
errorMessage: computed(() => errors.value[0]),
setErrors: (messages) => {
form.setFieldErrorBag(unref(path), normalizeErrors(messages));
}
};
}
function installDevtoolsPlugin(app) {
if (true) {
setupDevtoolsPlugin({
id: "vee-validate-devtools-plugin",
label: "VeeValidate Plugin",
packageName: "vee-validate",
homepage: "https://vee-validate.logaretm.com/v4",
app,
logo: "https://vee-validate.logaretm.com/v4/logo.png"
}, setupApiHooks);
}
}
var DEVTOOLS_FORMS = {};
var DEVTOOLS_FIELDS = {};
var API;
var refreshInspector = throttle(() => {
setTimeout(async () => {
await nextTick();
API === null || API === void 0 ? void 0 : API.sendInspectorState(INSPECTOR_ID);
API === null || API === void 0 ? void 0 : API.sendInspectorTree(INSPECTOR_ID);
}, 100);
}, 100);
function registerFormWithDevTools(form) {
const vm = getCurrentInstance();
if (!API) {
const app = vm === null || vm === void 0 ? void 0 : vm.appContext.app;
if (!app) {
return;
}
installDevtoolsPlugin(app);
}
DEVTOOLS_FORMS[form.formId] = Object.assign({}, form);
DEVTOOLS_FORMS[form.formId]._vm = vm;
onUnmounted(() => {
delete DEVTOOLS_FORMS[form.formId];
refreshInspector();
});
refreshInspector();
}
function registerSingleFieldWithDevtools(field) {
const vm = getCurrentInstance();
if (!API) {
const app = vm === null || vm === void 0 ? void 0 : vm.appContext.app;
if (!app) {
return;
}
installDevtoolsPlugin(app);
}
DEVTOOLS_FIELDS[field.id] = Object.assign({}, field);
DEVTOOLS_FIELDS[field.id]._vm = vm;
onUnmounted(() => {
delete DEVTOOLS_FIELDS[field.id];
refreshInspector();
});
refreshInspector();
}
var INSPECTOR_ID = "vee-validate-inspector";
var COLORS = {
error: 12405579,
success: 448379,
unknown: 5522283,
white: 16777215,
black: 0,
blue: 218007,
purple: 12157168,
orange: 16099682,
gray: 12304330
};
var SELECTED_NODE = null;
function setupApiHooks(api) {
API = api;
api.addInspector({
id: INSPECTOR_ID,
icon: "rule",
label: "vee-validate",
noSelectionText: "Select a vee-validate node to inspect",
actions: [
{
icon: "done_outline",
tooltip: "Validate selected item",
action: async () => {
if (!SELECTED_NODE) {
console.error("There is not a valid selected vee-validate node or component");
return;
}
const result = await SELECTED_NODE.validate();
console.log(result);
}
},
{
icon: "delete_sweep",
tooltip: "Clear validation state of the selected item",
action: () => {
if (!SELECTED_NODE) {
console.error("There is not a valid selected vee-validate node or component");
return;
}
if ("id" in SELECTED_NODE) {
SELECTED_NODE.resetField();
return;
}
SELECTED_NODE.resetForm();
}
}
]
});
api.on.getInspectorTree((payload) => {
if (payload.inspectorId !== INSPECTOR_ID) {
return;
}
const forms = Object.values(DEVTOOLS_FORMS);
const fields = Object.values(DEVTOOLS_FIELDS);
payload.rootNodes = [
...forms.map(mapFormForDevtoolsInspector),
...fields.map((field) => mapFieldForDevtoolsInspector(field))
];
});
api.on.getInspectorState((payload, ctx) => {
if (payload.inspectorId !== INSPECTOR_ID || ctx.currentTab !== `custom-inspector:${INSPECTOR_ID}`) {
return;
}
const { form, field, type } = decodeNodeId(payload.nodeId);
if (form && type === "form") {
payload.state = buildFormState(form);
SELECTED_NODE = form;
return;
}
if (field && type === "field") {
payload.state = buildFieldState(field);
SELECTED_NODE = field;
return;
}
SELECTED_NODE = null;
});
}
function mapFormForDevtoolsInspector(form) {
const { textColor, bgColor } = getTagTheme(form);
const formTreeNodes = {};
Object.values(form.fieldsByPath.value).forEach((field) => {
const fieldInstance = Array.isArray(field) ? field[0] : field;
if (!fieldInstance) {
return;
}
setInPath(formTreeNodes, unref(fieldInstance.name), mapFieldForDevtoolsInspector(fieldInstance, form));
});
function buildFormTree(tree, path = []) {
const key = [...path].pop();
if ("id" in tree) {
return Object.assign(Object.assign({}, tree), { label: key || tree.label });
}
if (isObject(tree)) {
return {
id: `${path.join(".")}`,
label: key || "",
children: Object.keys(tree).map((key2) => buildFormTree(tree[key2], [...path, key2]))
};
}
if (Array.isArray(tree)) {
return {
id: `${path.join(".")}`,
label: `${key}[]`,
children: tree.map((c, idx) => buildFormTree(c, [...path, String(idx)]))
};
}
return { id: "", label: "", children: [] };
}
const { children } = buildFormTree(formTreeNodes);
return {
id: encodeNodeId(form),
label: "Form",
children,
tags: [
{
label: "Form",
textColor,
backgroundColor: bgColor
},
{
label: `${Object.keys(form.fieldsByPath.value).length} fields`,
textColor: COLORS.white,
backgroundColor: COLORS.unknown
}
]
};
}
function mapFieldForDevtoolsInspector(field, form) {
const fieldInstance = normalizeField(field);
const { textColor, bgColor } = getTagTheme(fieldInstance);
const isGroup = Array.isArray(field) && field.length > 1;
return {
id: encodeNodeId(form, fieldInstance, !isGroup),
label: unref(fieldInstance.name),
children: Array.isArray(field) ? field.map((fieldItem) => mapFieldForDevtoolsInspector(fieldItem, form)) : void 0,
tags: [
isGroup ? void 0 : {
label: "Field",
textColor,
backgroundColor: bgColor
},
!form ? {
label: "Standalone",
textColor: COLORS.black,
backgroundColor: COLORS.gray
} : void 0,
!isGroup && fieldInstance.type === "checkbox" ? {
label: "Checkbox",
textColor: COLORS.white,
backgroundColor: COLORS.blue
} : void 0,
!isGroup && fieldInstance.type === "radio" ? {
label: "Radio",
textColor: COLORS.white,
backgroundColor: COLORS.purple
} : void 0,
isGroup ? {
label: "Group",
textColor: COLORS.black,
backgroundColor: COLORS.orange
} : void 0
].filter(Boolean)
};
}
function encodeNodeId(form, field, encodeIndex = true) {
const fieldPath = form ? unref(field === null || field === void 0 ? void 0 : field.name) : field === null || field === void 0 ? void 0 : field.id;
const fieldGroup = fieldPath ? form === null || form === void 0 ? void 0 : form.fieldsByPath.value[fieldPath] : void 0;
let idx;
if (encodeIndex && field && Array.isArray(fieldGroup)) {
idx = fieldGroup.indexOf(field);
}
const idObject = { f: form === null || form === void 0 ? void 0 : form.formId, ff: fieldPath, idx, type: field ? "field" : "form" };
return btoa(JSON.stringify(idObject));
}
function decodeNodeId(nodeId) {
try {
const idObject = JSON.parse(atob(nodeId));
const form = DEVTOOLS_FORMS[idObject.f];
if (!form && idObject.ff) {
const field = DEVTOOLS_FIELDS[idObject.ff];
if (!field) {
return {};
}
return {
type: idObject.type,
field
};
}
if (!form) {
return {};
}
const fieldGroup = form.fieldsByPath.value[idObject.ff];
return {
type: idObject.type,
form,
field: Array.isArray(fieldGroup) ? fieldGroup[idObject.idx || 0] : fieldGroup
};
} catch (err) {
}
return {};
}
function buildFieldState(field) {
const { errors, meta, value } = field;
return {
"Field state": [
{ key: "errors", value: errors.value },
{
key: "initialValue",
value: meta.initialValue
},
{
key: "currentValue",
value: value.value
},
{
key: "touched",
value: meta.touched
},
{
key: "dirty",
value: meta.dirty
},
{
key: "valid",
value: meta.valid
}
]
};
}
function buildFormState(form) {
const { errorBag, meta, values, isSubmitting, submitCount } = form;
return {
"Form state": [
{
key: "submitCount",
value: submitCount.value
},
{
key: "isSubmitting",
value: isSubmitting.value
},
{
key: "touched",
value: meta.value.touched
},
{
key: "dirty",
value: meta.value.dirty
},
{
key: "valid",
value: meta.value.valid
},
{
key: "initialValues",
value: meta.value.initialValues
},
{
key: "currentValues",
value: values
},
{
key: "errors",
value: keysOf(errorBag.value).reduce((acc, key) => {
var _a;
const message = (_a = errorBag.value[key]) === null || _a === void 0 ? void 0 : _a[0];
if (message) {
acc[key] = message;
}
return acc;
}, {})
}
]
};
}
function getTagTheme(fieldOrForm) {
const isValid = "id" in fieldOrForm ? fieldOrForm.meta.valid : fieldOrForm.meta.value.valid;
return {
bgColor: isValid ? COLORS.success : COLORS.error,
textColor: isValid ? COLORS.black : COLORS.white
};
}
function useField(name, rules, opts) {
if (hasCheckedAttr(opts === null || opts === void 0 ? void 0 : opts.type)) {
return useCheckboxField(name, rules, opts);
}
return _useField(name, rules, opts);
}
function _useField(name, rules, opts) {
const { initialValue: modelValue, validateOnMount, bails, type, checkedValue, label, validateOnValueUpdate, uncheckedValue, controlled, keepValueOnUnmount, modelPropName, syncVModel, form: controlForm } = normalizeOptions(unref(name), opts);
const injectedForm = controlled ? injectWithSelf(FormContextKey) : void 0;
const form = controlForm || injectedForm;
let markedForRemoval = false;
const { id, value, initialValue, meta, setState, errors, errorMessage } = useFieldState(name, {
modelValue,
form
});
if (syncVModel) {
useVModel({ value, prop: modelPropName, handleChange });
}
const handleBlur = () => {
meta.touched = true;
};
const normalizedRules = computed(() => {
let rulesValue = unref(rules);
const schema = unref(form === null || form === void 0 ? void 0 : form.schema);
if (schema && !isYupValidator(schema)) {
rulesValue = extractRuleFromSchema(schema, unref(name)) || rulesValue;
}
if (isYupValidator(rulesValue) || isCallable(rulesValue) || Array.isArray(rulesValue)) {
return rulesValue;
}
return normalizeRules(rulesValue);
});
async function validateCurrentValue(mode) {
var _a, _b;
if (form === null || form === void 0 ? void 0 : form.validateSchema) {
return (_a = (await form.validateSchema(mode)).results[unref(name)]) !== null && _a !== void 0 ? _a : { valid: true, errors: [] };
}
return validate(value.value, normalizedRules.value, {
name: unref(label) || unref(name),
values: (_b = form === null || form === void 0 ? void 0 : form.values) !== null && _b !== void 0 ? _b : {},
bails
});
}
const validateWithStateMutation = withLatest(async () => {
meta.pending = true;
meta.validated = true;
return validateCurrentValue("validated-only");
}, (result) => {
if (markedForRemoval) {
result.valid = true;
result.errors = [];
}
setState({ errors: result.errors });
meta.pending = false;
return result;
});
const validateValidStateOnly = withLatest(async () => {
return validateCurrentValue("silent");
}, (result) => {
if (markedForRemoval) {
result.valid = true;
}
meta.valid = result.valid;
return result;
});
function validate$1(opts2) {
if ((opts2 === null || opts2 === void 0 ? void 0 : opts2.mode) === "silent") {
return validateValidStateOnly();
}
return validateWithStateMutation();
}
function handleChange(e, shouldValidate = true) {
const newValue = normalizeEventValue(e);
value.value = newValue;
if (!validateOnValueUpdate && shouldValidate) {
validateWithStateMutation();
}
}
onMounted(() => {
if (validateOnMount) {
return validateWithStateMutation();
}
if (!form || !form.validateSchema) {
validateValidStateOnly();
}
});
function setTouched(isTouched) {
meta.touched = isTouched;
}
let unwatchValue;
let lastWatchedValue = klona(value.value);
function watchValue() {
unwatchValue = watch(value, (val, oldVal) => {
if (isEqual(val, oldVal) && isEqual(val, lastWatchedValue)) {
return;
}
const validateFn = validateOnValueUpdate ? validateWithStateMutation : validateValidStateOnly;
validateFn();
lastWatchedValue = klona(val);
}, {
deep: true
});
}
watchValue();
function resetField(state) {
var _a;
unwatchValue === null || unwatchValue === void 0 ? void 0 : unwatchValue();
const newValue = state && "value" in state ? state.value : initialValue.value;
setState({
value: klona(newValue),
initialValue: klona(newValue),
touched: (_a = state === null || state === void 0 ? void 0 : state.touched) !== null && _a !== void 0 ? _a : false,
errors: (state === null || state === void 0 ? void 0 : state.errors) || []
});
meta.pending = false;
meta.validated = false;
validateValidStateOnly();
nextTick(() => {
watchValue();
});
}
function setValue(newValue) {
value.value = newValue;
}
function setErrors(errors2) {
setState({ errors: Array.isArray(errors2) ? errors2 : [errors2] });
}
const field = {
id,
name,
label,
value,
meta,
errors,
errorMessage,
type,
checkedValue,
uncheckedValue,
bails,
keepValueOnUnmount,
resetField,
handleReset: () => resetField(),
validate: validate$1,
handleChange,
handleBlur,
setState,
setTouched,
setErrors,
setValue
};
provide(FieldContextKey, field);
if (isRef(rules) && typeof unref(rules) !== "function") {
watch(rules, (value2, oldValue) => {
if (isEqual(value2, oldValue)) {
return;
}
meta.validated ? validateWithStateMutation() : validateValidStateOnly();
}, {
deep: true
});
}
if (true) {
field._vm = getCurrentInstance();
watch(() => Object.assign(Object.assign({ errors: errors.value }, meta), { value: value.value }), refreshInspector, {
deep: true
});
if (!form) {
registerSingleFieldWithDevtools(field);
}
}
if (!form) {
return field;
}
form.register(field);
onBeforeUnmount(() => {
markedForRemoval = true;
form.unregister(field);
});
const dependencies = computed(() => {
const rulesVal = normalizedRules.value;
if (!rulesVal || isCallable(rulesVal) || isYupValidator(rulesVal) || Array.isArray(rulesVal)) {
return {};
}
return Object.keys(rulesVal).reduce((acc, rule) => {
const deps = extractLocators(rulesVal[rule]).map((dep) => dep.__locatorRef).reduce((depAcc, depName) => {
const depValue = getFromPath(form.values, depName) || form.values[depName];
if (depValue !== void 0) {
depAcc[depName] = depValue;
}
return depAcc;
}, {});
Object.assign(acc, deps);
return acc;
}, {});
});
watch(dependencies, (deps, oldDeps) => {
if (!Object.keys(deps).length) {
return;
}
const shouldValidate = !isEqual(deps, oldDeps);
if (shouldValidate) {
meta.validated ? validateWithStateMutation() : validateValidStateOnly();
}
});
return field;
}
function normalizeOptions(name, opts) {
const defaults = () => ({
initialValue: void 0,
validateOnMount: false,
bails: true,
label: name,
validateOnValueUpdate: true,
keepValueOnUnmount: void 0,
modelPropName: "modelValue",
syncVModel: true,
controlled: true
});
if (!opts) {
return defaults();
}
const checkedValue = "valueProp" in opts ? opts.valueProp : opts.checkedValue;
const controlled = "standalone" in opts ? !opts.standalone : opts.controlled;
return Object.assign(Object.assign(Object.assign({}, defaults()), opts || {}), { controlled: controlled !== null && controlled !== void 0 ? controlled : true, checkedValue });
}
function extractRuleFromSchema(schema, fieldName) {
if (!schema) {
return void 0;
}
return schema[fieldName];
}
function useCheckboxField(name, rules, opts) {
const form = !(opts === null || opts === void 0 ? void 0 : opts.standalone) ? injectWithSelf(FormContextKey) : void 0;
const checkedValue = opts === null || opts === void 0 ? void 0 : opts.checkedValue;
const uncheckedValue = opts === null || opts === void 0 ? void 0 : opts.uncheckedValue;
function patchCheckboxApi(field) {
const handleChange = field.handleChange;
const checked = computed(() => {
const currentValue = unref(field.value);
const checkedVal = unref(checkedValue);
return Array.isArray(currentValue) ? currentValue.findIndex((v) => isEqual(v, checkedVal)) >= 0 : isEqual(checkedVal, currentValue);
});
function handleCheckboxChange(e, shouldValidate = true) {
var _a;
if (checked.value === ((_a = e === null || e === void 0 ? void 0 : e.target) === null || _a === void 0 ? void 0 : _a.checked)) {
if (shouldValidate) {
field.validate();
}
return;
}
let newValue = normalizeEventValue(e);
if (!form) {
newValue = resolveNextCheckboxValue(unref(field.value), unref(checkedValue), unref(uncheckedValue));
}
handleChange(newValue, shouldValidate);
}
return Object.assign(Object.assign({}, field), {
checked,
checkedValue,
uncheckedValue,
handleChange: handleCheckboxChange
});
}
return patchCheckboxApi(_useField(name, rules, opts));
}
function useVModel({ prop, value, handleChange }) {
const vm = getCurrentInstance();
if (!vm) {
if (true) {
console.warn("Failed to setup model events because `useField` was not called in setup.");
}
return;
}
const propName = prop || "modelValue";
const emitName = `update:${propName}`;
if (!(propName in vm.props)) {
return;
}
watch(value, (newValue) => {
if (isEqual(newValue, getCurrentModelValue(vm, propName))) {
return;
}
vm.emit(emitName, newValue);
});
watch(() => getCurrentModelValue(vm, propName), (propValue) => {
if (propValue === IS_ABSENT && value.value === void 0) {
return;
}
const newValue = propValue === IS_ABSENT ? void 0 : propValue;
if (isEqual(newValue, applyModelModifiers(value.value, vm.props.modelModifiers))) {
return;
}
handleChange(newValue);
});
}
function getCurrentModelValue(vm, propName) {
return vm.props[propName];
}
var FieldImpl = defineComponent({
name: "Field",
inheritAttrs: false,
props: {
as: {
type: [String, Object],
default: void 0
},
name: {
type: String,
required: true
},
rules: {
type: [Object, String, Function],
default: void 0
},
validateOnMount: {
type: Boolean,
default: false
},
validateOnBlur: {
type: Boolean,
default: void 0
},
validateOnChange: {
type: Boolean,
default: void 0
},
validateOnInput: {
type: Boolean,
default: void 0
},
validateOnModelUpdate: {
type: Boolean,
default: void 0
},
bails: {
type: Boolean,
default: () => getConfig().bails
},
label: {
type: String,
default: void 0
},
uncheckedValue: {
type: null,
default: void 0
},
modelValue: {
type: null,
default: IS_ABSENT
},
modelModifiers: {
type: null,
default: () => ({})
},
"onUpdate:modelValue": {
type: null,
default: void 0
},
standalone: {
type: Boolean,
default: false
},
keepValue: {
type: Boolean,
default: void 0
}
},
setup(props, ctx) {
const rules = toRef(props, "rules");
const name = toRef(props, "name");
const label = toRef(props, "label");
const uncheckedValue = toRef(props, "uncheckedValue");
const keepValue = toRef(props, "keepValue");
const { errors, value, errorMessage, validate: validateField, handleChange, handleBlur, setTouched, resetField, handleReset, meta, checked, setErrors } = useField(name, rules, {
validateOnMount: props.validateOnMount,
bails: props.bails,
standalone: props.standalone,
type: ctx.attrs.type,
initialValue: resolveInitialValue(props, ctx),
// Only for checkboxes and radio buttons
checkedValue: ctx.attrs.value,
uncheckedValue,
label,
validateOnValueUpdate: false,
keepValueOnUnmount: keepValue
});
const onChangeHandler = function handleChangeWithModel(e, shouldValidate = true) {
handleChange(e, shouldValidate);
ctx.emit("update:modelValue", value.value);
};
const handleInput = (e) => {
if (!hasCheckedAttr(ctx.attrs.type)) {
value.value = normalizeEventValue(e);
}
};
const onInputHandler = function handleInputWithModel(e) {
handleInput(e);
ctx.emit("update:modelValue", value.value);
};
const fieldProps = computed(() => {
const { validateOnInput, validateOnChange, validateOnBlur, validateOnModelUpdate } = resolveValidationTriggers(props);
const baseOnBlur = [handleBlur, ctx.attrs.onBlur, validateOnBlur ? validateField : void 0].filter(Boolean);
const baseOnInput = [(e) => onChangeHandler(e, validateOnInput), ctx.attrs.onInput].filter(Boolean);
const baseOnChange = [(e) => onChangeHandler(e, validateOnChange), ctx.attrs.onChange].filter(Boolean);
const attrs = {
name: props.name,
onBlur: baseOnBlur,
onInput: baseOnInput,
onChange: baseOnChange
};
attrs["onUpdate:modelValue"] = (e) => onChangeHandler(e, validateOnModelUpdate);
if (hasCheckedAttr(ctx.attrs.type) && checked) {
attrs.checked = checked.value;
}
const tag = resolveTag(props, ctx);
if (shouldHaveValueBinding(tag, ctx.attrs)) {
attrs.value = value.value;
}
return attrs;
});
function slotProps() {
return {
field: fieldProps.value,
value: value.value,
meta,
errors: errors.value,
errorMessage: errorMessage.value,
validate: validateField,
resetField,
handleChange: onChangeHandler,
handleInput: onInputHandler,
handleReset,
handleBlur,
setTouched,
setErrors
};
}
ctx.expose({
setErrors,
setTouched,
reset: resetField,
validate: validateField,
handleChange
});
return () => {
const tag = resolveDynamicComponent(resolveTag(props, ctx));
const children = normalizeChildren(tag, ctx, slotProps);
if (tag) {
return h(tag, Object.assign(Object.assign({}, ctx.attrs), fieldProps.value), children);
}
return children;
};
}
});
function resolveTag(props, ctx) {
let tag = props.as || "";
if (!props.as && !ctx.slots.default) {
tag = "input";
}
return tag;
}
function resolveValidationTriggers(props) {
var _a, _b, _c, _d;
const { validateOnInput, validateOnChange, validateOnBlur, validateOnModelUpdate } = getConfig();
return {
validateOnInput: (_a = props.validateOnInput) !== null && _a !== void 0 ? _a : validateOnInput,
validateOnChange: (_b = props.validateOnChange) !== null && _b !== void 0 ? _b : validateOnChange,
validateOnBlur: (_c = props.validateOnBlur) !== null && _c !== void 0 ? _c : validateOnBlur,
validateOnModelUpdate: (_d = props.validateOnModelUpdate) !== null && _d !== void 0 ? _d : validateOnModelUpdate
};
}
function resolveInitialValue(props, ctx) {
if (!hasCheckedAttr(ctx.attrs.type)) {
return isPropPresent(props, "modelValue") ? props.modelValue : ctx.attrs.value;
}
return isPropPresent(props, "modelValue") ? props.modelValue : void 0;
}
var Field = FieldImpl;
var FORM_COUNTER = 0;
function useForm(opts) {
var _a;
const formId = FORM_COUNTER++;
const controlledModelPaths = /* @__PURE__ */ new Set();
let RESET_LOCK = false;
const fieldsByPath = ref({});
const isSubmitting = ref(false);
const submitCount = ref(0);
const fieldArrays = [];
const formValues = reactive(klona(unref(opts === null || opts === void 0 ? void 0 : opts.initialValues) || {}));
const { errorBag, setErrorBag, setFieldErrorBag } = useErrorBag(opts === null || opts === void 0 ? void 0 : opts.initialErrors);
const errors = computed(() => {
return keysOf(errorBag.value).reduce((acc, key) => {
const bag = errorBag.value[key];
if (bag && bag.length) {
acc[key] = bag[0];
}
return acc;
}, {});
});
function getFirstFieldAtPath(path) {
const fieldOrGroup = fieldsByPath.value[path];
return Array.isArray(fieldOrGroup) ? fieldOrGroup[0] : fieldOrGroup;
}
function fieldExists(path) {
return !!fieldsByPath.value[path];
}
const fieldNames = computed(() => {
return keysOf(fieldsByPath.value).reduce((names, path) => {
const field = getFirstFieldAtPath(path);
if (field) {
names[path] = unref(field.label || field.name) || "";
}
return names;
}, {});
});
const fieldBailsMap = computed(() => {
return keysOf(fieldsByPath.value).reduce((map, path) => {
var _a2;
const field = getFirstFieldAtPath(path);
if (field) {
map[path] = (_a2 = field.bails) !== null && _a2 !== void 0 ? _a2 : true;
}
return map;
}, {});
});
const initialErrors = Object.assign({}, (opts === null || opts === void 0 ? void 0 : opts.initialErrors) || {});
const keepValuesOnUnmount = (_a = opts === null || opts === void 0 ? void 0 : opts.keepValuesOnUnmount) !== null && _a !== void 0 ? _a : false;
const { initialValues, originalInitialValues, setInitialValues } = useFormInitialValues(fieldsByPath, formValues, opts === null || opts === void 0 ? void 0 : opts.initialValues);
const meta = useFormMeta(fieldsByPath, formValues, originalInitialValues, errors);
const controlledValues = computed(() => {
return [...controlledModelPaths, ...keysOf(fieldsByPath.value)].reduce((acc, path) => {
const value = getFromPath(formValues, path);
setInPath(acc, path, value);
return acc;
}, {});
});
const schema = opts === null || opts === void 0 ? void 0 : opts.validationSchema;
const debouncedSilentValidation = debounceAsync(_validateSchema, 5);
const debouncedValidation = debounceAsync(_validateSchema, 5);
const validateSchema = withLatest(async (mode) => {
return await mode === "silent" ? debouncedSilentValidation() : debouncedValidation();
}, (formResult, [mode]) => {
const fieldsById = formCtx.fieldsByPath.value || {};
const currentErrorsPaths = keysOf(formCtx.errorBag.value);
const paths = [
.../* @__PURE__ */ new Set([...keysOf(formResult.results), ...keysOf(fieldsById), ...currentErrorsPaths])
];
return paths.reduce((validation, path) => {
const field = fieldsById[path];
const messages = (formResult.results[path] || { errors: [] }).errors;
const fieldResult = {
errors: messages,
valid: !messages.length
};
validation.results[path] = fieldResult;
if (!fieldResult.valid) {
validation.errors[path] = fieldResult.errors[0];
}
if (!field) {
setFieldError(path, messages);
return validation;
}
applyFieldMutation(field, (f) => f.meta.valid = fieldResult.valid);
if (mode === "silent") {
return validation;
}
const wasValidated = Array.isArray(field) ? field.some((f) => f.meta.validated) : field.meta.validated;
if (mode === "validated-only" && !wasValidated) {
return validation;
}
applyFieldMutation(field, (f) => f.setState({ errors: fieldResult.errors }));
return validation;
}, { valid: formResult.valid, results: {}, errors: {} });
});
function makeSubmissionFactory(onlyControlled) {
return function submitHandlerFactory(fn, onValidationError) {
return function submissionHandler(e) {
if (e instanceof Event) {
e.preventDefault();
e.stopPropagation();
}
setTouched(keysOf(fieldsByPath.value).reduce((acc, field) => {
acc[field] = true;
return acc;
}, {}));
isSubmitting.value = true;
submitCount.value++;
return validate2().then((result) => {
const values = klona(formValues);
if (result.valid && typeof fn === "function") {
const controlled = klona(controlledValues.value);
return fn(onlyControlled ? controlled : values, {
evt: e,
controlledValues: controlled,
setErrors,
setFieldError,
setTouched,
setFieldTouched,
setValues,
setFieldValue,
resetForm
});
}
if (!result.valid && typeof onValidationError === "function") {
onValidationError({
values,
evt: e,
errors: result.errors,
results: result.results
});
}
}).then((returnVal) => {
isSubmitting.value = false;
return returnVal;
}, (err) => {
isSubmitting.value = false;
throw err;
});
};
};
}
const handleSubmitImpl = makeSubmissionFactory(false);
const handleSubmit = handleSubmitImpl;
handleSubmit.withControlled = makeSubmissionFactory(true);
const formCtx = {
formId,
fieldsByPath,
values: formValues,
controlledValues,
errorBag,
errors,
schema,
submitCount,
meta,
isSubmitting,
fieldArrays,
keepValuesOnUnmount,
validateSchema: unref(schema) ? validateSchema : void 0,
validate: validate2,
register: registerField,
unregister: unregisterField,
setFieldErrorBag,
validateField,
setFieldValue,
setValues,
setErrors,
setFieldError,
setFieldTouched,
setTouched,
resetForm,
handleSubmit,
stageInitialValue,
unsetInitialValue,
setFieldInitialValue,
useFieldModel
};
function isFieldGroup(fieldOrGroup) {
return Array.isArray(fieldOrGroup);
}
function applyFieldMutation(fieldOrGroup, mutation) {
if (Array.isArray(fieldOrGroup)) {
return fieldOrGroup.forEach(mutation);
}
return mutation(fieldOrGroup);
}
function mutateAllFields(mutation) {
Object.values(fieldsByPath.value).forEach((field) => {
if (!field) {
return;
}
applyFieldMutation(field, mutation);
});
}
function setFieldError(field, message) {
setFieldErrorBag(field, message);
}
function setErrors(fields) {
setErrorBag(fields);
}
function setFieldValue(field, value, { force } = { force: false }) {
var _a2;
const fieldInstance = fieldsByPath.value[field];
const clonedValue = klona(value);
if (!fieldInstance) {
setInPath(formValues, field, clonedValue);
return;
}
if (isFieldGroup(fieldInstance) && ((_a2 = fieldInstance[0]) === null || _a2 === void 0 ? void 0 : _a2.type) === "checkbox" && !Array.isArray(value)) {
const newValue2 = klona(resolveNextCheckboxValue(getFromPath(formValues, field) || [], value, void 0));
setInPath(formValues, field, newValue2);
return;
}
let newValue = value;
if (!isFieldGroup(fieldInstance) && fieldInstance.type === "checkbox" && !force && !RESET_LOCK) {
newValue = klona(resolveNextCheckboxValue(getFromPath(formValues, field), value, unref(fieldInstance.uncheckedValue)));
}
setInPath(formValues, field, newValue);
}
function setValues(fields) {
keysOf(formValues).forEach((key) => {
delete formValues[key];
});
keysOf(fields).forEach((path) => {
setFieldValue(path, fields[path]);
});
fieldArrays.forEach((f) => f && f.reset());
}
function createModel(path) {
const { value } = _useFieldValue(path, void 0, formCtx);
watch(value, () => {
if (!fieldExists(unref(path))) {
validate2({ mode: "validated-only" });
}
}, {
deep: true
});
controlledModelPaths.add(unref(path));
return value;
}
function useFieldModel(path) {
if (!Array.isArray(path)) {
return createModel(path);
}
return path.map(createModel);
}
function setFieldTouched(field, isTouched) {
const fieldInstance = fieldsByPath.value[field];
if (fieldInstance) {
applyFieldMutation(fieldInstance, (f) => f.setTouched(isTouched));
}
}
function setTouched(fields) {
keysOf(fields).forEach((field) => {
setFieldTouched(field, !!fields[field]);
});
}
function resetForm(state) {
RESET_LOCK = true;
mutateAllFields((f) => f.resetField());
if (state === null || state === void 0 ? void 0 : state.values) {
setInitialValues(state.values);
setValues(state === null || state === void 0 ? void 0 : state.values);
} else {
setInitialValues(originalInitialValues.value);
setValues(originalInitialValues.value);
}
if (state === null || state === void 0 ? void 0 : state.touched) {
setTouched(state.touched);
}
setErrors((state === null || state === void 0 ? void 0 : state.errors) || {});
submitCount.value = (state === null || state === void 0 ? void 0 : state.submitCount) || 0;
nextTick(() => {
RESET_LOCK = false;
});
}
function insertFieldAtPath(field, path) {
const rawField = markRaw(field);
const fieldPath = path;
if (!fieldsByPath.value[fieldPath]) {
fieldsByPath.value[fieldPath] = rawField;
return;
}
const fieldAtPath = fieldsByPath.value[fieldPath];
if (fieldAtPath && !Array.isArray(fieldAtPath)) {
fieldsByPath.value[fieldPath] = [fieldAtPath];
}
fieldsByPath.value[fieldPath] = [...fieldsByPath.value[fieldPath], rawField];
}
function removeFieldFromPath(field, path) {
const fieldPath = path;
const fieldAtPath = fieldsByPath.value[fieldPath];
if (!fieldAtPath) {
return;
}
if (!isFieldGroup(fieldAtPath) && field.id === fieldAtPath.id) {
delete fieldsByPath.value[fieldPath];
return;
}
if (isFieldGroup(fieldAtPath)) {
const idx = fieldAtPath.findIndex((f) => f.id === field.id);
if (idx === -1) {
return;
}
fieldAtPath.splice(idx, 1);
if (!fieldAtPath.length) {
delete fieldsByPath.value[fieldPath];
}
}
}
function registerField(field) {
const fieldPath = unref(field.name);
insertFieldAtPath(field, fieldPath);
if (isRef(field.name)) {
watch(field.name, async (newPath, oldPath) => {
await nextTick();
removeFieldFromPath(field, oldPath);
insertFieldAtPath(field, newPath);
if (errors.value[oldPath] || errors.value[newPath]) {
setFieldError(oldPath, void 0);
validateField(newPath);
}
await nextTick();
if (!fieldExists(oldPath)) {
unsetPath(formValues, oldPath);
}
});
}
const initialErrorMessage = unref(field.errorMessage);
if (initialErrorMessage && (initialErrors === null || initialErrors === void 0 ? void 0 : initialErrors[fieldPath]) !== initialErrorMessage) {
validateField(fieldPath);
}
delete initialErrors[fieldPath];
}
function unregisterField(field) {
const fieldName = unref(field.name);
const fieldInstance = fieldsByPath.value[fieldName];
const isGroup = !!fieldInstance && isFieldGroup(fieldInstance);
removeFieldFromPath(field, fieldName);
nextTick(() => {
var _a2;
const shouldKeepValue = (_a2 = unref(field.keepValueOnUnmount)) !== null && _a2 !== void 0 ? _a2 : unref(keepValuesOnUnmount);
const currentGroupValue = getFromPath(formValues, fieldName);
const isSameGroup = isGroup && (fieldInstance === fieldsByPath.value[fieldName] || !fieldsByPath.value[fieldName]);
if (isSameGroup && Array.isArray(currentGroupValue) && !shouldKeepValue) {
const valueIdx = currentGroupValue.findIndex((i) => isEqual(i, unref(field.checkedValue)));
if (valueIdx > -1) {
const newVal = [...currentGroupValue];
newVal.splice(valueIdx, 1);
setFieldValue(fieldName, newVal, { force: true });
}
}
if (!fieldExists(fieldName)) {
setFieldError(fieldName, void 0);
if (shouldKeepValue) {
return;
}
if (isGroup && !isEmptyContainer(getFromPath(formValues, fieldName))) {
return;
}
unsetPath(formValues, fieldName);
}
});
}
async function validate2(opts2) {
mutateAllFields((f) => f.meta.validated = true);
if (formCtx.validateSchema) {
return formCtx.validateSchema((opts2 === null || opts2 === void 0 ? void 0 : opts2.mode) || "force");
}
const validations = await Promise.all(Object.values(fieldsByPath.value).map((field) => {
const fieldInstance = Array.isArray(field) ? field[0] : field;
if (!fieldInstance) {
return Promise.resolve({ key: "", valid: true, errors: [] });
}
return fieldInstance.validate(opts2).then((result) => {
return {
key: unref(fieldInstance.name),
valid: result.valid,
errors: result.errors
};
});
}));
const results = {};
const errors2 = {};
for (const validation of validations) {
results[validation.key] = {
valid: validation.valid,
errors: validation.errors
};
if (validation.errors.length) {
errors2[validation.key] = validation.errors[0];
}
}
return {
valid: validations.every((r) => r.valid),
results,
errors: errors2
};
}
async function validateField(field) {
const fieldInstance = fieldsByPath.value[field];
if (!fieldInstance) {
warn$1(`field with name ${field} was not found`);
return Promise.resolve({ errors: [], valid: true });
}
if (Array.isArray(fieldInstance)) {
return fieldInstance.map((f) => f.validate())[0];
}
return fieldInstance.validate();
}
function unsetInitialValue(path) {
unsetPath(initialValues.value, path);
}
function stageInitialValue(path, value, updateOriginal = false) {
setInPath(formValues, path, value);
setFieldInitialValue(path, value);
if (updateOriginal && !(opts === null || opts === void 0 ? void 0 : opts.initialValues)) {
setInPath(originalInitialValues.value, path, klona(value));
}
}
function setFieldInitialValue(path, value) {
setInPath(initialValues.value, path, klona(value));
}
async function _validateSchema() {
const schemaValue = unref(schema);
if (!schemaValue) {
return { valid: true, results: {}, errors: {} };
}
const formResult = isYupValidator(schemaValue) ? await validateYupSchema(schemaValue, formValues) : await validateObjectSchema(schemaValue, formValues, {
names: fieldNames.value,
bailsMap: fieldBailsMap.value
});
return formResult;
}
const submitForm = handleSubmit((_, { evt }) => {
if (isFormSubmitEvent(evt)) {
evt.target.submit();
}
});
onMounted(() => {
if (opts === null || opts === void 0 ? void 0 : opts.initialErrors) {
setErrors(opts.initialErrors);
}
if (opts === null || opts === void 0 ? void 0 : opts.initialTouched) {
setTouched(opts.initialTouched);
}
if (opts === null || opts === void 0 ? void 0 : opts.validateOnMount) {
validate2();
return;
}
if (formCtx.validateSchema) {
formCtx.validateSchema("silent");
}
});
if (isRef(schema)) {
watch(schema, () => {
var _a2;
(_a2 = formCtx.validateSchema) === null || _a2 === void 0 ? void 0 : _a2.call(formCtx, "validated-only");
});
}
provide(FormContextKey, formCtx);
if (true) {
registerFormWithDevTools(formCtx);
watch(() => Object.assign(Object.assign({ errors: errorBag.value }, meta.value), { values: formValues, isSubmitting: isSubmitting.value, submitCount: submitCount.value }), refreshInspector, {
deep: true
});
}
return Object.assign(Object.assign({}, formCtx), { handleReset: () => resetForm(), submitForm });
}
function useFormMeta(fieldsByPath, currentValues, initialValues, errors) {
const MERGE_STRATEGIES = {
touched: "some",
pending: "some",
valid: "every"
};
const isDirty = computed(() => {
return !isEqual(currentValues, unref(initialValues));
});
function calculateFlags() {
const fields = Object.values(fieldsByPath.value).flat(1).filter(Boolean);
return keysOf(MERGE_STRATEGIES).reduce((acc, flag) => {
const mergeMethod = MERGE_STRATEGIES[flag];
acc[flag] = fields[mergeMethod]((field) => field.meta[flag]);
return acc;
}, {});
}
const flags = reactive(calculateFlags());
watchEffect(() => {
const value = calculateFlags();
flags.touched = value.touched;
flags.valid = value.valid;
flags.pending = value.pending;
});
return computed(() => {
return Object.assign(Object.assign({ initialValues: unref(initialValues) }, flags), { valid: flags.valid && !keysOf(errors.value).length, dirty: isDirty.value });
});
}
function useFormInitialValues(fields, formValues, providedValues) {
const initialValues = ref(klona(unref(providedValues)) || {});
const originalInitialValues = ref(klona(unref(providedValues)) || {});
function setInitialValues(values, updateFields = false) {
initialValues.value = klona(values);
originalInitialValues.value = klona(values);
if (!updateFields) {
return;
}
keysOf(fields.value).forEach((fieldPath) => {
const field = fields.value[fieldPath];
const wasTouched = Array.isArray(field) ? field.some((f) => f.meta.touched) : field === null || field === void 0 ? void 0 : field.meta.touched;
if (!field || wasTouched) {
return;
}
const newValue = getFromPath(initialValues.value, fieldPath);
setInPath(formValues, fieldPath, klona(newValue));
});
}
if (isRef(providedValues)) {
watch(providedValues, (value) => {
setInitialValues(value, true);
}, {
deep: true
});
}
return {
initialValues,
originalInitialValues,
setInitialValues
};
}
function useErrorBag(initialErrors) {
const errorBag = ref({});
function normalizeErrorItem(message) {
return Array.isArray(message) ? message : message ? [message] : [];
}
function setFieldErrorBag(field, message) {
if (!message) {
delete errorBag.value[field];
return;
}
errorBag.value[field] = normalizeErrorItem(message);
}
function setErrorBag(fields) {
errorBag.value = keysOf(fields).reduce((acc, key) => {
const message = fields[key];
if (message) {
acc[key] = normalizeErrorItem(message);
}
return acc;
}, {});
}
if (initialErrors) {
setErrorBag(initialErrors);
}
return {
errorBag,
setErrorBag,
setFieldErrorBag
};
}
var FormImpl = defineComponent({
name: "Form",
inheritAttrs: false,
props: {
as: {
type: String,
default: "form"
},
validationSchema: {
type: Object,
default: void 0
},
initialValues: {
type: Object,
default: void 0
},
initialErrors: {
type: Object,
default: void 0
},
initialTouched: {
type: Object,
default: void 0
},
validateOnMount: {
type: Boolean,
default: false
},
onSubmit: {
type: Function,
default: void 0
},
onInvalidSubmit: {
type: Function,
default: void 0
},
keepValues: {
type: Boolean,
default: false
}
},
setup(props, ctx) {
const initialValues = toRef(props, "initialValues");
const validationSchema = toRef(props, "validationSchema");
const keepValues = toRef(props, "keepValues");
const { errors, values, meta, isSubmitting, submitCount, controlledValues, validate: validate2, validateField, handleReset, resetForm, handleSubmit, setErrors, setFieldError, setFieldValue, setValues, setFieldTouched, setTouched } = useForm({
validationSchema: validationSchema.value ? validationSchema : void 0,
initialValues,
initialErrors: props.initialErrors,
initialTouched: props.initialTouched,
validateOnMount: props.validateOnMount,
keepValuesOnUnmount: keepValues
});
const submitForm = handleSubmit((_, { evt }) => {
if (isFormSubmitEvent(evt)) {
evt.target.submit();
}
}, props.onInvalidSubmit);
const onSubmit = props.onSubmit ? handleSubmit(props.onSubmit, props.onInvalidSubmit) : submitForm;
function handleFormReset(e) {
if (isEvent(e)) {
e.preventDefault();
}
handleReset();
if (typeof ctx.attrs.onReset === "function") {
ctx.attrs.onReset();
}
}
function handleScopedSlotSubmit(evt, onSubmit2) {
const onSuccess = typeof evt === "function" && !onSubmit2 ? evt : onSubmit2;
return handleSubmit(onSuccess, props.onInvalidSubmit)(evt);
}
function slotProps() {
return {
meta: meta.value,
errors: errors.value,
values,
isSubmitting: isSubmitting.value,
submitCount: submitCount.value,
controlledValues: controlledValues.value,
validate: validate2,
validateField,
handleSubmit: handleScopedSlotSubmit,
handleReset,
submitForm,
setErrors,
setFieldError,
setFieldValue,
setValues,
setFieldTouched,
setTouched,
resetForm
};
}
ctx.expose({
setFieldError,
setErrors,
setFieldValue,
setValues,
setFieldTouched,
setTouched,
resetForm,
validate: validate2,
validateField
});
return function renderForm() {
const tag = props.as === "form" ? props.as : resolveDynamicComponent(props.as);
const children = normalizeChildren(tag, ctx, slotProps);
if (!props.as) {
return children;
}
const formAttrs = props.as === "form" ? {
// Disables native validation as vee-validate will handle it.
novalidate: true
} : {};
return h(tag, Object.assign(Object.assign(Object.assign({}, formAttrs), ctx.attrs), { onSubmit, onReset: handleFormReset }), children);
};
}
});
var Form = FormImpl;
function useFieldArray(arrayPath) {
const form = injectWithSelf(FormContextKey, void 0);
const fields = ref([]);
const noOp = () => {
};
const noOpApi = {
fields,
remove: noOp,
push: noOp,
swap: noOp,
insert: noOp,
update: noOp,
replace: noOp,
prepend: noOp,
move: noOp
};
if (!form) {
warn("FieldArray requires being a child of `` or `useForm` being called before it. Array fields may not work correctly");
return noOpApi;
}
if (!unref(arrayPath)) {
warn("FieldArray requires a field path to be provided, did you forget to pass the `name` prop?");
return noOpApi;
}
const alreadyExists = form.fieldArrays.find((a) => unref(a.path) === unref(arrayPath));
if (alreadyExists) {
return alreadyExists;
}
let entryCounter = 0;
function initFields() {
const currentValues = getFromPath(form === null || form === void 0 ? void 0 : form.values, unref(arrayPath), []) || [];
fields.value = currentValues.map(createEntry);
updateEntryFlags();
}
initFields();
function updateEntryFlags() {
const fieldsLength = fields.value.length;
for (let i = 0; i < fieldsLength; i++) {
const entry = fields.value[i];
entry.isFirst = i === 0;
entry.isLast = i === fieldsLength - 1;
}
}
function createEntry(value) {
const key = entryCounter++;
const entry = {
key,
value: computed({
get() {
const currentValues = getFromPath(form === null || form === void 0 ? void 0 : form.values, unref(arrayPath), []) || [];
const idx = fields.value.findIndex((e) => e.key === key);
return idx === -1 ? value : currentValues[idx];
},
set(value2) {
const idx = fields.value.findIndex((e) => e.key === key);
if (idx === -1) {
warn(`Attempting to update a non-existent array item`);
return;
}
update(idx, value2);
}
}),
isFirst: false,
isLast: false
};
return entry;
}
function remove(idx) {
const pathName = unref(arrayPath);
const pathValue = getFromPath(form === null || form === void 0 ? void 0 : form.values, pathName);
if (!pathValue || !Array.isArray(pathValue)) {
return;
}
const newValue = [...pathValue];
newValue.splice(idx, 1);
form === null || form === void 0 ? void 0 : form.unsetInitialValue(pathName + `[${idx}]`);
form === null || form === void 0 ? void 0 : form.setFieldValue(pathName, newValue);
fields.value.splice(idx, 1);
updateEntryFlags();
}
function push(value) {
const pathName = unref(arrayPath);
const pathValue = getFromPath(form === null || form === void 0 ? void 0 : form.values, pathName);
const normalizedPathValue = isNullOrUndefined(pathValue) ? [] : pathValue;
if (!Array.isArray(normalizedPathValue)) {
return;
}
const newValue = [...normalizedPathValue];
newValue.push(value);
form === null || form === void 0 ? void 0 : form.stageInitialValue(pathName + `[${newValue.length - 1}]`, value);
form === null || form === void 0 ? void 0 : form.setFieldValue(pathName, newValue);
fields.value.push(createEntry(value));
updateEntryFlags();
}
function swap(indexA, indexB) {
const pathName = unref(arrayPath);
const pathValue = getFromPath(form === null || form === void 0 ? void 0 : form.values, pathName);
if (!Array.isArray(pathValue) || !(indexA in pathValue) || !(indexB in pathValue)) {
return;
}
const newValue = [...pathValue];
const newFields = [...fields.value];
const temp = newValue[indexA];
newValue[indexA] = newValue[indexB];
newValue[indexB] = temp;
const tempEntry = newFields[indexA];
newFields[indexA] = newFields[indexB];
newFields[indexB] = tempEntry;
form === null || form === void 0 ? void 0 : form.setFieldValue(pathName, newValue);
fields.value = newFields;
updateEntryFlags();
}
function insert(idx, value) {
const pathName = unref(arrayPath);
const pathValue = getFromPath(form === null || form === void 0 ? void 0 : form.values, pathName);
if (!Array.isArray(pathValue) || pathValue.length < idx) {
return;
}
const newValue = [...pathValue];
const newFields = [...fields.value];
newValue.splice(idx, 0, value);
newFields.splice(idx, 0, createEntry(value));
form === null || form === void 0 ? void 0 : form.setFieldValue(pathName, newValue);
fields.value = newFields;
updateEntryFlags();
}
function replace(arr) {
const pathName = unref(arrayPath);
form === null || form === void 0 ? void 0 : form.setFieldValue(pathName, arr);
initFields();
}
function update(idx, value) {
const pathName = unref(arrayPath);
const pathValue = getFromPath(form === null || form === void 0 ? void 0 : form.values, pathName);
if (!Array.isArray(pathValue) || pathValue.length - 1 < idx) {
return;
}
form === null || form === void 0 ? void 0 : form.setFieldValue(`${pathName}[${idx}]`, value);
}
function prepend(value) {
const pathName = unref(arrayPath);
const pathValue = getFromPath(form === null || form === void 0 ? void 0 : form.values, pathName);
const normalizedPathValue = isNullOrUndefined(pathValue) ? [] : pathValue;
if (!Array.isArray(normalizedPathValue)) {
return;
}
const newValue = [value, ...normalizedPathValue];
form === null || form === void 0 ? void 0 : form.stageInitialValue(pathName + `[${newValue.length - 1}]`, value);
form === null || form === void 0 ? void 0 : form.setFieldValue(pathName, newValue);
fields.value.unshift(createEntry(value));
updateEntryFlags();
}
function move(oldIdx, newIdx) {
const pathName = unref(arrayPath);
const pathValue = getFromPath(form === null || form === void 0 ? void 0 : form.values, pathName);
const newValue = isNullOrUndefined(pathValue) ? [] : [...pathValue];
if (!Array.isArray(pathValue) || !(oldIdx in pathValue) || !(newIdx in pathValue)) {
return;
}
const newFields = [...fields.value];
const movedItem = newFields[oldIdx];
newFields.splice(oldIdx, 1);
newFields.splice(newIdx, 0, movedItem);
const movedValue = newValue[oldIdx];
newValue.splice(oldIdx, 1);
newValue.splice(newIdx, 0, movedValue);
form === null || form === void 0 ? void 0 : form.setFieldValue(pathName, newValue);
fields.value = newFields;
updateEntryFlags();
}
const fieldArrayCtx = {
fields,
remove,
push,
swap,
insert,
update,
replace,
prepend,
move
};
form.fieldArrays.push(Object.assign({ path: arrayPath, reset: initFields }, fieldArrayCtx));
onBeforeUnmount(() => {
const idx = form.fieldArrays.findIndex((i) => unref(i.path) === unref(arrayPath));
if (idx >= 0) {
form.fieldArrays.splice(idx, 1);
}
});
return fieldArrayCtx;
}
var FieldArrayImpl = defineComponent({
name: "FieldArray",
inheritAttrs: false,
props: {
name: {
type: String,
required: true
}
},
setup(props, ctx) {
const { push, remove, swap, insert, replace, update, prepend, move, fields } = useFieldArray(toRef(props, "name"));
function slotProps() {
return {
fields: fields.value,
push,
remove,
swap,
insert,
update,
replace,
prepend,
move
};
}
ctx.expose({
push,
remove,
swap,
insert,
update,
replace,
prepend,
move
});
return () => {
const children = normalizeChildren(void 0, ctx, slotProps);
return children;
};
}
});
var FieldArray = FieldArrayImpl;
var ErrorMessageImpl = defineComponent({
name: "ErrorMessage",
props: {
as: {
type: String,
default: void 0
},
name: {
type: String,
required: true
}
},
setup(props, ctx) {
const form = inject(FormContextKey, void 0);
const message = computed(() => {
return form === null || form === void 0 ? void 0 : form.errors.value[props.name];
});
function slotProps() {
return {
message: message.value
};
}
return () => {
if (!message.value) {
return void 0;
}
const tag = props.as ? resolveDynamicComponent(props.as) : props.as;
const children = normalizeChildren(tag, ctx, slotProps);
const attrs = Object.assign({ role: "alert" }, ctx.attrs);
if (!tag && (Array.isArray(children) || !children) && (children === null || children === void 0 ? void 0 : children.length)) {
return children;
}
if ((Array.isArray(children) || !children) && !(children === null || children === void 0 ? void 0 : children.length)) {
return h(tag || "span", attrs, message.value);
}
return h(tag, attrs, children);
};
}
});
var ErrorMessage = ErrorMessageImpl;
function useResetForm() {
const form = injectWithSelf(FormContextKey);
if (!form) {
warn("No vee-validate or `useForm` was detected in the component tree");
}
return function resetForm(state) {
if (!form) {
return;
}
return form.resetForm(state);
};
}
function useIsFieldDirty(path) {
const form = injectWithSelf(FormContextKey);
let field = path ? void 0 : inject(FieldContextKey);
return computed(() => {
if (path) {
field = normalizeField(form === null || form === void 0 ? void 0 : form.fieldsByPath.value[unref(path)]);
}
if (!field) {
warn(`field with name ${unref(path)} was not found`);
return false;
}
return field.meta.dirty;
});
}
function useIsFieldTouched(path) {
const form = injectWithSelf(FormContextKey);
let field = path ? void 0 : inject(FieldContextKey);
return computed(() => {
if (path) {
field = normalizeField(form === null || form === void 0 ? void 0 : form.fieldsByPath.value[unref(path)]);
}
if (!field) {
warn(`field with name ${unref(path)} was not found`);
return false;
}
return field.meta.touched;
});
}
function useIsFieldValid(path) {
const form = injectWithSelf(FormContextKey);
let field = path ? void 0 : inject(FieldContextKey);
return computed(() => {
if (path) {
field = normalizeField(form === null || form === void 0 ? void 0 : form.fieldsByPath.value[unref(path)]);
}
if (!field) {
warn(`field with name ${unref(path)} was not found`);
return false;
}
return field.meta.valid;
});
}
function useIsSubmitting() {
const form = injectWithSelf(FormContextKey);
if (!form) {
warn("No vee-validate or `useForm` was detected in the component tree");
}
return computed(() => {
var _a;
return (_a = form === null || form === void 0 ? void 0 : form.isSubmitting.value) !== null && _a !== void 0 ? _a : false;
});
}
function useValidateField(path) {
const form = injectWithSelf(FormContextKey);
let field = path ? void 0 : inject(FieldContextKey);
return function validateField() {
if (path) {
field = normalizeField(form === null || form === void 0 ? void 0 : form.fieldsByPath.value[unref(path)]);
}
if (!field) {
warn(`field with name ${unref(path)} was not found`);
return Promise.resolve({
errors: [],
valid: true
});
}
return field.validate();
};
}
function useIsFormDirty() {
const form = injectWithSelf(FormContextKey);
if (!form) {
warn("No vee-validate or `useForm` was detected in the component tree");
}
return computed(() => {
var _a;
return (_a = form === null || form === void 0 ? void 0 : form.meta.value.dirty) !== null && _a !== void 0 ? _a : false;
});
}
function useIsFormTouched() {
const form = injectWithSelf(FormContextKey);
if (!form) {
warn("No vee-validate or `useForm` was detected in the component tree");
}
return computed(() => {
var _a;
return (_a = form === null || form === void 0 ? void 0 : form.meta.value.touched) !== null && _a !== void 0 ? _a : false;
});
}
function useIsFormValid() {
const form = injectWithSelf(FormContextKey);
if (!form) {
warn("No vee-validate or `useForm` was detected in the component tree");
}
return computed(() => {
var _a;
return (_a = form === null || form === void 0 ? void 0 : form.meta.value.valid) !== null && _a !== void 0 ? _a : false;
});
}
function useValidateForm() {
const form = injectWithSelf(FormContextKey);
if (!form) {
warn("No vee-validate or `useForm` was detected in the component tree");
}
return function validateField() {
if (!form) {
return Promise.resolve({ results: {}, errors: {}, valid: true });
}
return form.validate();
};
}
function useSubmitCount() {
const form = injectWithSelf(FormContextKey);
if (!form) {
warn("No vee-validate or `useForm` was detected in the component tree");
}
return computed(() => {
var _a;
return (_a = form === null || form === void 0 ? void 0 : form.submitCount.value) !== null && _a !== void 0 ? _a : 0;
});
}
function useFieldValue(path) {
const form = injectWithSelf(FormContextKey);
const field = path ? void 0 : inject(FieldContextKey);
return computed(() => {
if (path) {
return getFromPath(form === null || form === void 0 ? void 0 : form.values, unref(path));
}
return unref(field === null || field === void 0 ? void 0 : field.value);
});
}
function useFormValues() {
const form = injectWithSelf(FormContextKey);
if (!form) {
warn("No vee-validate or `useForm` was detected in the component tree");
}
return computed(() => {
return (form === null || form === void 0 ? void 0 : form.values) || {};
});
}
function useFormErrors() {
const form = injectWithSelf(FormContextKey);
if (!form) {
warn("No vee-validate or `useForm` was detected in the component tree");
}
return computed(() => {
return (form === null || form === void 0 ? void 0 : form.errors.value) || {};
});
}
function useFieldError(path) {
const form = injectWithSelf(FormContextKey);
const field = path ? void 0 : inject(FieldContextKey);
return computed(() => {
if (path) {
return form === null || form === void 0 ? void 0 : form.errors.value[unref(path)];
}
return field === null || field === void 0 ? void 0 : field.errorMessage.value;
});
}
function useSubmitForm(cb) {
const form = injectWithSelf(FormContextKey);
if (!form) {
warn("No vee-validate or `useForm` was detected in the component tree");
}
const onSubmit = form ? form.handleSubmit(cb) : void 0;
return function submitForm(e) {
if (!onSubmit) {
return;
}
return onSubmit(e);
};
}
export {
ErrorMessage,
Field,
FieldArray,
FieldContextKey,
Form,
FormContextKey,
IS_ABSENT,
configure,
defineRule,
useField,
useFieldArray,
useFieldError,
useFieldValue,
useForm,
useFormErrors,
useFormValues,
useIsFieldDirty,
useIsFieldTouched,
useIsFieldValid,
useIsFormDirty,
useIsFormTouched,
useIsFormValid,
useIsSubmitting,
useResetForm,
useSubmitCount,
useSubmitForm,
useValidateField,
useValidateForm,
validate
};
/*! Bundled license information:
vee-validate/dist/vee-validate.esm.js:
(**
* vee-validate v4.7.0
* (c) 2022 Abdelrahman Awad
* @license MIT
*)
*/
//# sourceMappingURL=vee-validate.js.map