initial vitepress site with basic nav

node_modules/@vueuse/integrations/useAsyncValidator/component.cjs

@@ -0,0 +1,113 @@
+'use strict';
+
+var vueDemi = require('vue-demi');
+var shared = require('@vueuse/shared');
+var Schema = require('async-validator');
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const AsyncValidatorSchema = Schema.default || Schema;
+function useAsyncValidator(value, rules, options = {}) {
+  const {
+    validateOption = {},
+    immediate = true,
+    manual = false
+  } = options;
+  const valueRef = shared.toRef(value);
+  const errorInfo = vueDemi.shallowRef(null);
+  const isFinished = vueDemi.ref(true);
+  const pass = vueDemi.ref(!immediate || manual);
+  const errors = vueDemi.computed(() => {
+    var _a;
+    return ((_a = errorInfo.value) == null ? void 0 : _a.errors) || [];
+  });
+  const errorFields = vueDemi.computed(() => {
+    var _a;
+    return ((_a = errorInfo.value) == null ? void 0 : _a.fields) || {};
+  });
+  const validator = vueDemi.computed(() => new AsyncValidatorSchema(shared.toValue(rules)));
+  const execute = async () => {
+    isFinished.value = false;
+    pass.value = false;
+    try {
+      await validator.value.validate(valueRef.value, validateOption);
+      pass.value = true;
+      errorInfo.value = null;
+    } catch (err) {
+      errorInfo.value = err;
+    } finally {
+      isFinished.value = true;
+    }
+    return {
+      pass: pass.value,
+      errorInfo: errorInfo.value,
+      errors: errors.value,
+      errorFields: errorFields.value
+    };
+  };
+  if (!manual) {
+    vueDemi.watch(
+      [valueRef, validator],
+      () => execute(),
+      { immediate, deep: true }
+    );
+  }
+  const shell = {
+    isFinished,
+    pass,
+    errors,
+    errorInfo,
+    errorFields,
+    execute
+  };
+  function waitUntilFinished() {
+    return new Promise((resolve, reject) => {
+      shared.until(isFinished).toBe(true).then(() => resolve(shell)).catch((error) => reject(error));
+    });
+  }
+  return __spreadProps(__spreadValues({}, shell), {
+    then(onFulfilled, onRejected) {
+      return waitUntilFinished().then(onFulfilled, onRejected);
+    }
+  });
+}
+
+const UseAsyncValidator = /* @__PURE__ */ /* #__PURE__ */ vueDemi.defineComponent({
+  name: "UseAsyncValidator",
+  props: {
+    form: {
+      type: Object,
+      required: true
+    },
+    rules: {
+      type: Object,
+      required: true
+    }
+  },
+  setup(props, { slots }) {
+    const data = vueDemi.reactive(useAsyncValidator(props.form, props.rules));
+    return () => {
+      if (slots.default)
+        return slots.default(data);
+    };
+  }
+});
+
+exports.UseAsyncValidator = UseAsyncValidator;

node_modules/@vueuse/integrations/useAsyncValidator/component.d.ts

@@ -0,0 +1,27 @@
+import * as vue_demi from 'vue-demi';
+import { PropType } from 'vue-demi';
+import { Rules } from 'async-validator';
+
+declare const UseAsyncValidator: vue_demi.DefineComponent<{
+    form: {
+        type: PropType<Record<string, any>>;
+        required: true;
+    };
+    rules: {
+        type: PropType<Rules>;
+        required: true;
+    };
+}, () => vue_demi.VNode<vue_demi.RendererNode, vue_demi.RendererElement, {
+    [key: string]: any;
+}>[] | undefined, unknown, {}, {}, vue_demi.ComponentOptionsMixin, vue_demi.ComponentOptionsMixin, {}, string, vue_demi.VNodeProps & vue_demi.AllowedComponentProps & vue_demi.ComponentCustomProps, Readonly<vue_demi.ExtractPropTypes<{
+    form: {
+        type: PropType<Record<string, any>>;
+        required: true;
+    };
+    rules: {
+        type: PropType<Rules>;
+        required: true;
+    };
+}>>, {}>;
+
+export { UseAsyncValidator };

node_modules/@vueuse/integrations/useAsyncValidator/component.mjs

@@ -0,0 +1,111 @@
+import { shallowRef, ref, computed, watch, defineComponent, reactive } from 'vue-demi';
+import { toRef, toValue, until } from '@vueuse/shared';
+import Schema from 'async-validator';
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const AsyncValidatorSchema = Schema.default || Schema;
+function useAsyncValidator(value, rules, options = {}) {
+  const {
+    validateOption = {},
+    immediate = true,
+    manual = false
+  } = options;
+  const valueRef = toRef(value);
+  const errorInfo = shallowRef(null);
+  const isFinished = ref(true);
+  const pass = ref(!immediate || manual);
+  const errors = computed(() => {
+    var _a;
+    return ((_a = errorInfo.value) == null ? void 0 : _a.errors) || [];
+  });
+  const errorFields = computed(() => {
+    var _a;
+    return ((_a = errorInfo.value) == null ? void 0 : _a.fields) || {};
+  });
+  const validator = computed(() => new AsyncValidatorSchema(toValue(rules)));
+  const execute = async () => {
+    isFinished.value = false;
+    pass.value = false;
+    try {
+      await validator.value.validate(valueRef.value, validateOption);
+      pass.value = true;
+      errorInfo.value = null;
+    } catch (err) {
+      errorInfo.value = err;
+    } finally {
+      isFinished.value = true;
+    }
+    return {
+      pass: pass.value,
+      errorInfo: errorInfo.value,
+      errors: errors.value,
+      errorFields: errorFields.value
+    };
+  };
+  if (!manual) {
+    watch(
+      [valueRef, validator],
+      () => execute(),
+      { immediate, deep: true }
+    );
+  }
+  const shell = {
+    isFinished,
+    pass,
+    errors,
+    errorInfo,
+    errorFields,
+    execute
+  };
+  function waitUntilFinished() {
+    return new Promise((resolve, reject) => {
+      until(isFinished).toBe(true).then(() => resolve(shell)).catch((error) => reject(error));
+    });
+  }
+  return __spreadProps(__spreadValues({}, shell), {
+    then(onFulfilled, onRejected) {
+      return waitUntilFinished().then(onFulfilled, onRejected);
+    }
+  });
+}
+
+const UseAsyncValidator = /* @__PURE__ */ /* #__PURE__ */ defineComponent({
+  name: "UseAsyncValidator",
+  props: {
+    form: {
+      type: Object,
+      required: true
+    },
+    rules: {
+      type: Object,
+      required: true
+    }
+  },
+  setup(props, { slots }) {
+    const data = reactive(useAsyncValidator(props.form, props.rules));
+    return () => {
+      if (slots.default)
+        return slots.default(data);
+    };
+  }
+});
+
+export { UseAsyncValidator };