yc-design-vue 1.7.8 → 1.8.0

package/es/node_modules/@vue/devtools-api/lib/esm/const.js

@@ -0,0 +1,6 @@
+const HOOK_SETUP = "devtools-plugin:setup";
+const HOOK_PLUGIN_SETTINGS_SET = "plugin:settings:set";
+export {
+  HOOK_PLUGIN_SETTINGS_SET,
+  HOOK_SETUP
+};

package/es/node_modules/@vue/devtools-api/lib/esm/env.js

@@ -0,0 +1,12 @@
+function getDevtoolsGlobalHook() {
+  return getTarget().__VUE_DEVTOOLS_GLOBAL_HOOK__;
+}
+function getTarget() {
+  return typeof navigator !== "undefined" && typeof window !== "undefined" ? window : typeof globalThis !== "undefined" ? globalThis : {};
+}
+const isProxyAvailable = typeof Proxy === "function";
+export {
+  getDevtoolsGlobalHook,
+  getTarget,
+  isProxyAvailable
+};

package/es/node_modules/@vue/devtools-api/lib/esm/index.js

@@ -0,0 +1,26 @@
+import { getTarget, getDevtoolsGlobalHook, isProxyAvailable } from "./env.js";
+import { HOOK_SETUP } from "./const.js";
+import { ApiProxy } from "./proxy.js";
+function setupDevtoolsPlugin(pluginDescriptor, setupFn) {
+  const descriptor = pluginDescriptor;
+  const target = getTarget();
+  const hook = getDevtoolsGlobalHook();
+  const enableProxy = isProxyAvailable && descriptor.enableEarlyProxy;
+  if (hook && (target.__VUE_DEVTOOLS_PLUGIN_API_AVAILABLE__ || !enableProxy)) {
+    hook.emit(HOOK_SETUP, pluginDescriptor, setupFn);
+  } else {
+    const proxy = enableProxy ? new ApiProxy(descriptor, hook) : null;
+    const list = target.__VUE_DEVTOOLS_PLUGINS__ = target.__VUE_DEVTOOLS_PLUGINS__ || [];
+    list.push({
+      pluginDescriptor: descriptor,
+      setupFn,
+      proxy
+    });
+    if (proxy) {
+      setupFn(proxy.proxiedTarget);
+    }
+  }
+}
+export {
+  setupDevtoolsPlugin
+};

package/es/node_modules/@vue/devtools-api/lib/esm/proxy.js

@@ -0,0 +1,103 @@
+import { HOOK_PLUGIN_SETTINGS_SET } from "./const.js";
+import { now } from "./time.js";
+class ApiProxy {
+  constructor(plugin, hook) {
+    this.target = null;
+    this.targetQueue = [];
+    this.onQueue = [];
+    this.plugin = plugin;
+    this.hook = hook;
+    const defaultSettings = {};
+    if (plugin.settings) {
+      for (const id in plugin.settings) {
+        const item = plugin.settings[id];
+        defaultSettings[id] = item.defaultValue;
+      }
+    }
+    const localSettingsSaveId = `__vue-devtools-plugin-settings__${plugin.id}`;
+    let currentSettings = Object.assign({}, defaultSettings);
+    try {
+      const raw = localStorage.getItem(localSettingsSaveId);
+      const data = JSON.parse(raw);
+      Object.assign(currentSettings, data);
+    } catch (e) {
+    }
+    this.fallbacks = {
+      getSettings() {
+        return currentSettings;
+      },
+      setSettings(value) {
+        try {
+          localStorage.setItem(localSettingsSaveId, JSON.stringify(value));
+        } catch (e) {
+        }
+        currentSettings = value;
+      },
+      now() {
+        return now();
+      }
+    };
+    if (hook) {
+      hook.on(HOOK_PLUGIN_SETTINGS_SET, (pluginId, value) => {
+        if (pluginId === this.plugin.id) {
+          this.fallbacks.setSettings(value);
+        }
+      });
+    }
+    this.proxiedOn = new Proxy({}, {
+      get: (_target, prop) => {
+        if (this.target) {
+          return this.target.on[prop];
+        } else {
+          return (...args) => {
+            this.onQueue.push({
+              method: prop,
+              args
+            });
+          };
+        }
+      }
+    });
+    this.proxiedTarget = new Proxy({}, {
+      get: (_target, prop) => {
+        if (this.target) {
+          return this.target[prop];
+        } else if (prop === "on") {
+          return this.proxiedOn;
+        } else if (Object.keys(this.fallbacks).includes(prop)) {
+          return (...args) => {
+            this.targetQueue.push({
+              method: prop,
+              args,
+              resolve: () => {
+              }
+            });
+            return this.fallbacks[prop](...args);
+          };
+        } else {
+          return (...args) => {
+            return new Promise((resolve) => {
+              this.targetQueue.push({
+                method: prop,
+                args,
+                resolve
+              });
+            });
+          };
+        }
+      }
+    });
+  }
+  async setRealTarget(target) {
+    this.target = target;
+    for (const item of this.onQueue) {
+      this.target.on[item.method](...item.args);
+    }
+    for (const item of this.targetQueue) {
+      item.resolve(await this.target[item.method](...item.args));
+    }
+  }
+}
+export {
+  ApiProxy
+};

package/es/node_modules/@vue/devtools-api/lib/esm/time.js

@@ -0,0 +1,25 @@
+let supported;
+let perf;
+function isPerformanceSupported() {
+  var _a;
+  if (supported !== void 0) {
+    return supported;
+  }
+  if (typeof window !== "undefined" && window.performance) {
+    supported = true;
+    perf = window.performance;
+  } else if (typeof globalThis !== "undefined" && ((_a = globalThis.perf_hooks) === null || _a === void 0 ? void 0 : _a.performance)) {
+    supported = true;
+    perf = globalThis.perf_hooks.performance;
+  } else {
+    supported = false;
+  }
+  return supported;
+}
+function now() {
+  return isPerformanceSupported() ? perf.now() : Date.now();
+}
+export {
+  isPerformanceSupported,
+  now
+};

package/es/node_modules/b-validate/es/is.js

@@ -0,0 +1,27 @@
+var opt = Object.prototype.toString;
+function isArray(obj) {
+  return opt.call(obj) === "[object Array]";
+}
+function isObject(obj) {
+  return opt.call(obj) === "[object Object]";
+}
+function isString(obj) {
+  return opt.call(obj) === "[object String]";
+}
+function isFunction(obj) {
+  return opt.call(obj) === "[object Function]";
+}
+function isEmptyValue(obj) {
+  return obj === void 0 || obj === null || obj === "";
+}
+function isEmptyArray(obj) {
+  return isArray(obj) && !obj.length;
+}
+export {
+  isArray,
+  isEmptyArray,
+  isEmptyValue,
+  isFunction,
+  isObject,
+  isString
+};

package/es/node_modules/b-validate/es/locale/en-US.js

@@ -0,0 +1,50 @@
+var defaultTypeTemplate = "#{field} is not a #{type} type";
+var defaultValidateLocale = {
+  required: "#{field} is required",
+  type: {
+    ip: defaultTypeTemplate,
+    email: defaultTypeTemplate,
+    url: defaultTypeTemplate,
+    string: defaultTypeTemplate,
+    number: defaultTypeTemplate,
+    array: defaultTypeTemplate,
+    object: defaultTypeTemplate,
+    boolean: defaultTypeTemplate
+  },
+  number: {
+    min: "`#{value}` is not greater than `#{min}`",
+    max: "`#{value}` is not less than `#{max}`",
+    equal: "`#{value}` is not equal to `#{equal}`",
+    range: "`#{value}` is not in range `#{min} ~ #{max}`",
+    positive: "`#{value}` is not a positive number",
+    negative: "`#{value}` is not a negative number"
+  },
+  string: {
+    maxLength: "#{field} cannot be longer than #{maxLength} characters",
+    minLength: "#{field} must be at least #{minLength} characters",
+    length: "#{field} must be exactly #{length} characters",
+    match: "`#{value}` does not match pattern #{pattern}",
+    uppercase: "`#{value}` must be all uppercase",
+    lowercase: "`#{value}` must be all lowercased"
+  },
+  array: {
+    length: "#{field} must be exactly #{length} in length",
+    minLength: "#{field} cannot be less than #{minLength} in length",
+    maxLength: "#{field} cannot be greater than #{maxLength} in length",
+    includes: "#{field} is not includes #{includes}",
+    deepEqual: "#{field} is not deep equal with #{deepEqual}",
+    empty: "#{field} is not an empty array"
+  },
+  object: {
+    deepEqual: "#{field} is not deep equal to expected value",
+    hasKeys: "#{field} does not contain required fields",
+    empty: "#{field} is not an empty object"
+  },
+  boolean: {
+    true: "Expect true but got `#{value}`",
+    false: "Expect false but got `#{value}`"
+  }
+};
+export {
+  defaultValidateLocale as default
+};

package/es/node_modules/b-validate/es/rules/base.js

@@ -0,0 +1,86 @@
+import { isObject, isFunction, isString, isArray, isEmptyValue, isEmptyArray } from "../is.js";
+import { getTemplate, mergeTemplate } from "../util.js";
+import defaultValidateLocale from "../locale/en-US.js";
+var Base = function Base2(obj, options) {
+  var this$1$1 = this;
+  this.getValidateMsg = function(keyPath, info) {
+    if (info === void 0) info = {};
+    var data = Object.assign(Object.assign({}, info), { value: this$1$1.obj, field: this$1$1.field, type: this$1$1.type });
+    var template = getTemplate(this$1$1.validateMessages, keyPath);
+    if (isFunction(template)) {
+      return template(data);
+    }
+    if (isString(template)) {
+      return template.replace(/\#\{.+?\}/g, function(variable) {
+        var key = variable.slice(2, -1);
+        if (key in data) {
+          if (isObject(data[key]) || isArray(data[key])) {
+            try {
+              return JSON.stringify(data[key]);
+            } catch (_) {
+              return data[key];
+            }
+          }
+          return String(data[key]);
+        }
+        return variable;
+      });
+    }
+    return template;
+  };
+  if (isObject(options) && isString(obj) && options.trim) {
+    this.obj = obj.trim();
+  } else if (isObject(options) && options.ignoreEmptyString && obj === "") {
+    this.obj = void 0;
+  } else {
+    this.obj = obj;
+  }
+  this.message = options.message;
+  this.type = options.type;
+  this.error = null;
+  this.field = options.field || options.type;
+  this.validateMessages = mergeTemplate(defaultValidateLocale, options.validateMessages);
+};
+var prototypeAccessors = { not: { configurable: true }, isRequired: { configurable: true }, end: { configurable: true } };
+prototypeAccessors.not.get = function() {
+  this._not = !this._not;
+  return this;
+};
+prototypeAccessors.isRequired.get = function() {
+  if (isEmptyValue(this.obj) || isEmptyArray(this.obj)) {
+    var message = this.getValidateMsg("required");
+    this.error = {
+      value: this.obj,
+      type: this.type,
+      requiredError: true,
+      message: this.message || (isObject(message) ? message : (this._not ? "[NOT MODE]:" : "") + message)
+    };
+  }
+  return this;
+};
+prototypeAccessors.end.get = function() {
+  return this.error;
+};
+Base.prototype.addError = function addError(message) {
+  if (!this.error && message) {
+    this.error = {
+      value: this.obj,
+      type: this.type,
+      message: this.message || (isObject(message) ? message : (this._not ? "[NOT MODE]:" : "") + message)
+    };
+  }
+};
+Base.prototype.validate = function validate(expression, errorMessage) {
+  var _expression = this._not ? expression : !expression;
+  if (_expression) {
+    this.addError(errorMessage);
+  }
+  return this;
+};
+Base.prototype.collect = function collect(callback) {
+  callback && callback(this.error);
+};
+Object.defineProperties(Base.prototype, prototypeAccessors);
+export {
+  Base as default
+};

package/es/node_modules/b-validate/es/util.js

@@ -0,0 +1,25 @@
+import { isObject } from "./is.js";
+var mergeTemplate = function(defaultValidateMessages, validateMessages) {
+  var result = Object.assign({}, defaultValidateMessages);
+  Object.keys(validateMessages || {}).forEach(function(key) {
+    var defaultValue = result[key];
+    var newValue = validateMessages === null || validateMessages === void 0 ? void 0 : validateMessages[key];
+    result[key] = isObject(defaultValue) ? Object.assign(Object.assign({}, defaultValue), newValue) : newValue || defaultValue;
+  });
+  return result;
+};
+var getTemplate = function(validateMessages, keyPath) {
+  var keys = keyPath.split(".");
+  var result = validateMessages;
+  for (var i = 0; i < keys.length; i++) {
+    result = result && result[keys[i]];
+    if (result === void 0) {
+      return result;
+    }
+  }
+  return result;
+};
+export {
+  getTemplate,
+  mergeTemplate
+};