@rhino-design/vue 0.2.1 → 0.2.3

package/dist/composables/form.js

@@ -0,0 +1,397 @@
+import { computed as c, provide as h, inject as b } from "vue";
+const p = ["success", "warning", "error", "validating"], z = ["change", "input", "focus", "blur"], v = Symbol("x-form"), E = Symbol("x-form-item"), A = /^[^\s@]+@[^\s@]+\.[^\s@]+$/, $ = /^(https?:\/\/)([\w-]+\.)+[\w-]+(:\d+)?(\/[^\s]*)?$/i, F = /^(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}$/;
+function R(e) {
+  return String(e).replace(/\[(\w+)\]/g, ".$1").replace(/^\./, "");
+}
+function S(e, r, i = !1) {
+  const a = R(r).split(".");
+  let u = e, o = 0;
+  for (; o < a.length - 1; o += 1) {
+    const t = a[o];
+    if (!u && !i)
+      break;
+    if (u && t in u)
+      u = u[t];
+    else {
+      if (i)
+        throw new Error("please transfer a valid prop path to form item!");
+      break;
+    }
+  }
+  const s = a[o] ?? "";
+  return {
+    o: u,
+    k: s,
+    v: u == null ? void 0 : u[s]
+  };
+}
+function k(e, r, i) {
+  const a = R(r).split("."), u = a.pop();
+  if (!u)
+    return;
+  let o = e;
+  for (const s of a) {
+    const t = o[s];
+    (!t || typeof t != "object") && (o[s] = {}), o = o[s];
+  }
+  o[u] = i;
+}
+function B(e, r) {
+  return S(e, r).v;
+}
+function O(e, r, i) {
+  k(e, r, i);
+}
+function P(e, r) {
+  const i = String(r).replace(/[[.]/g, "_").replace(/\]/g, "");
+  return e ? `${e}-${i}` : i;
+}
+function w(e) {
+  return Array.isArray(e) ? e : e == null ? [] : [e];
+}
+function g(e) {
+  return Object.prototype.toString.call(e) === "[object Object]";
+}
+function m(e) {
+  return e == null ? !0 : typeof e == "string" ? e.trim().length === 0 : Array.isArray(e) ? e.length === 0 : !1;
+}
+function y(e, r) {
+  if (Object.is(e, r))
+    return !0;
+  if (Array.isArray(e) && Array.isArray(r))
+    return e.length !== r.length ? !1 : e.every((i, n) => y(i, r[n]));
+  if (g(e) && g(r)) {
+    const i = Object.keys(e), n = Object.keys(r);
+    return i.length !== n.length ? !1 : i.every((a) => y(e[a], r[a]));
+  }
+  return !1;
+}
+function x(e, r) {
+  if (!e.type)
+    return !0;
+  switch (e.type) {
+    case "string":
+      return typeof r == "string";
+    case "number":
+      return typeof r == "number" && !Number.isNaN(r);
+    case "boolean":
+      return typeof r == "boolean";
+    case "array":
+      return Array.isArray(r);
+    case "object":
+      return g(r);
+    case "email":
+      return typeof r == "string" && A.test(r);
+    case "url":
+      return typeof r == "string" && $.test(r.trim());
+    case "ip":
+      return typeof r == "string" && F.test(r.trim());
+    default:
+      return !0;
+  }
+}
+function l(e, r) {
+  return e.message && String(e.message).trim().length > 0 ? e.message : r;
+}
+async function V(e, r, i) {
+  const n = e.validator;
+  if (n)
+    return new Promise((a) => {
+      let u = !1;
+      const o = (t) => {
+        u || (u = !0, a(t ? String(t) : void 0));
+      }, s = (t) => {
+        if (typeof t == "string")
+          return t;
+        if (t === !1)
+          return e.message ?? "Validation failed";
+      };
+      try {
+        const t = n(r, o, i);
+        if (t instanceof Promise) {
+          t.then((f) => {
+            u || o(s(f));
+          }).catch((f) => {
+            const d = f instanceof Error ? f.message : String(f ?? "Validation failed");
+            o(d);
+          });
+          return;
+        }
+        if (t !== void 0) {
+          o(s(t));
+          return;
+        }
+        n.length < 2 && o();
+      } catch (t) {
+        const f = t instanceof Error ? t.message : String(t ?? "Validation failed");
+        o(f);
+      }
+    });
+}
+function j(e, r) {
+  if (!r || r === "submit")
+    return !0;
+  const i = w(e.trigger);
+  return i.length === 0 ? !0 : i.includes(r);
+}
+async function X(e) {
+  const { field: r, label: i, value: n, rules: a, model: u, trigger: o } = e, s = i || r || "This field";
+  for (const t of a) {
+    if (!j(t, o))
+      continue;
+    if (t.required && m(n))
+      return {
+        type: "required",
+        message: l(t, `${s} is required`),
+        isRequiredError: !0
+      };
+    if (m(n))
+      continue;
+    if (!x(t, n))
+      return {
+        type: t.type ?? "type",
+        message: l(t, `${s} type is invalid`),
+        isRequiredError: !1
+      };
+    if (typeof t.length == "number" && (Array.isArray(n) ? n.length : String(n).length) !== t.length)
+      return {
+        type: "length",
+        message: l(t, `${s} length is invalid`),
+        isRequiredError: !1
+      };
+    if (typeof t.minLength == "number" && (Array.isArray(n) ? n.length : String(n).length) < t.minLength)
+      return {
+        type: "minLength",
+        message: l(t, `${s} is too short`),
+        isRequiredError: !1
+      };
+    if (typeof t.maxLength == "number" && (Array.isArray(n) ? n.length : String(n).length) > t.maxLength)
+      return {
+        type: "maxLength",
+        message: l(t, `${s} is too long`),
+        isRequiredError: !1
+      };
+    if (t.match && !t.match.test(String(n)))
+      return {
+        type: "match",
+        message: l(t, `${s} format is invalid`),
+        isRequiredError: !1
+      };
+    if (t.uppercase && String(n) !== String(n).toUpperCase())
+      return {
+        type: "uppercase",
+        message: l(t, `${s} must be uppercase`),
+        isRequiredError: !1
+      };
+    if (t.lowercase && String(n) !== String(n).toLowerCase())
+      return {
+        type: "lowercase",
+        message: l(t, `${s} must be lowercase`),
+        isRequiredError: !1
+      };
+    if (typeof n == "number") {
+      if (typeof t.min == "number" && n < t.min)
+        return {
+          type: "min",
+          message: l(t, `${s} is too small`),
+          isRequiredError: !1
+        };
+      if (typeof t.max == "number" && n > t.max)
+        return {
+          type: "max",
+          message: l(t, `${s} is too large`),
+          isRequiredError: !1
+        };
+      if (typeof t.equal == "number" && n !== t.equal)
+        return {
+          type: "equal",
+          message: l(t, `${s} is invalid`),
+          isRequiredError: !1
+        };
+      if (t.positive && n <= 0)
+        return {
+          type: "positive",
+          message: l(t, `${s} must be positive`),
+          isRequiredError: !1
+        };
+      if (t.negative && n >= 0)
+        return {
+          type: "negative",
+          message: l(t, `${s} must be negative`),
+          isRequiredError: !1
+        };
+    }
+    if (typeof n == "boolean") {
+      if (t.true && n !== !0)
+        return {
+          type: "true",
+          message: l(t, `${s} must be true`),
+          isRequiredError: !1
+        };
+      if (t.false && n !== !1)
+        return {
+          type: "false",
+          message: l(t, `${s} must be false`),
+          isRequiredError: !1
+        };
+    }
+    if (Array.isArray(n)) {
+      if (t.includes && !t.includes.every((d) => n.includes(d)))
+        return {
+          type: "includes",
+          message: l(t, `${s} has invalid value`),
+          isRequiredError: !1
+        };
+      if (t.deepEqual !== void 0 && !y(n, t.deepEqual))
+        return {
+          type: "deepEqual",
+          message: l(t, `${s} is invalid`),
+          isRequiredError: !1
+        };
+    }
+    if (g(n)) {
+      if (t.empty && Object.keys(n).length > 0)
+        return {
+          type: "empty",
+          message: l(t, `${s} must be empty`),
+          isRequiredError: !1
+        };
+      if (t.hasKeys && !t.hasKeys.every((d) => d in n))
+        return {
+          type: "hasKeys",
+          message: l(t, `${s} is invalid`),
+          isRequiredError: !1
+        };
+    }
+    const f = await V(t, n, u);
+    if (f)
+      return {
+        type: "validator",
+        message: f,
+        isRequiredError: !1
+      };
+  }
+}
+function _(e) {
+  let r = "";
+  for (const i of Object.keys(e)) {
+    const n = e[i];
+    n && (!r || p.indexOf(n) > p.indexOf(r)) && (r = n);
+  }
+  return r;
+}
+function K(e) {
+  const r = [];
+  for (const i of Object.keys(e)) {
+    const n = e[i];
+    n && r.push(n);
+  }
+  return r;
+}
+function T(e) {
+  h(v, e);
+}
+function C() {
+  return b(v, null);
+}
+function D(e) {
+  h(E, e);
+}
+function q() {
+  return b(E, null);
+}
+function H(e = {}) {
+  const r = q(), i = c(() => {
+    var s;
+    return ((s = e.size) == null ? void 0 : s.value) ?? (r == null ? void 0 : r.size.value) ?? "medium";
+  }), n = c(() => {
+    var s;
+    return !!(((s = e.disabled) == null ? void 0 : s.value) ?? (r == null ? void 0 : r.disabled.value));
+  }), a = c(() => {
+    var s;
+    return !!(((s = e.error) == null ? void 0 : s.value) ?? (r == null ? void 0 : r.error.value));
+  }), u = c(() => {
+    var s;
+    return ((s = e.feedback) == null ? void 0 : s.value) ?? (r == null ? void 0 : r.feedback.value);
+  }), o = c(() => (r == null ? void 0 : r.eventHandlers.value) ?? {});
+  return {
+    id: r == null ? void 0 : r.id,
+    mergedSize: i,
+    mergedDisabled: n,
+    mergedError: a,
+    feedback: u,
+    eventHandlers: o
+  };
+}
+function M() {
+  const e = q(), r = c(() => (e == null ? void 0 : e.eventHandlers.value) ?? {});
+  return {
+    id: e == null ? void 0 : e.id,
+    size: c(() => (e == null ? void 0 : e.size.value) ?? "medium"),
+    disabled: c(() => !!(e != null && e.disabled.value)),
+    error: c(() => !!(e != null && e.error.value)),
+    feedback: c(() => e == null ? void 0 : e.feedback.value),
+    eventHandlers: r,
+    notifyChange: (i) => {
+      var n, a;
+      (a = (n = r.value).onChange) == null || a.call(n, i);
+    },
+    notifyInput: (i) => {
+      var n, a;
+      (a = (n = r.value).onInput) == null || a.call(n, i);
+    },
+    notifyFocus: (i) => {
+      var n, a;
+      (a = (n = r.value).onFocus) == null || a.call(n, i);
+    },
+    notifyBlur: (i) => {
+      var n, a;
+      (a = (n = r.value).onBlur) == null || a.call(n, i);
+    }
+  };
+}
+function N() {
+  return /* @__PURE__ */ new Map();
+}
+async function U(e) {
+  const r = await Promise.all([...e.values()].map((a) => a.validate())), i = {};
+  let n = !1;
+  return r.forEach((a) => {
+    a && (n = !0, i[a.field] = a);
+  }), {
+    valid: !n,
+    errors: n ? i : void 0
+  };
+}
+function G(e) {
+  e.forEach((r) => r.clearValidate());
+}
+function J(e) {
+  e.forEach((r) => r.resetField());
+}
+function Q(e) {
+  return c(() => !!e.value);
+}
+export {
+  p as X_VALIDATE_STATUSES,
+  z as X_VALIDATE_TRIGGERS,
+  G as clearFields,
+  Q as createDisabledRef,
+  N as createFieldRegistry,
+  B as getByPath,
+  K as getFinalValidateMessage,
+  _ as getFinalValidateStatus,
+  P as getFormElementId,
+  S as getValueByPath,
+  T as provideXForm,
+  D as provideXFormField,
+  J as resetFields,
+  O as setByPath,
+  k as setValueByPath,
+  C as useXForm,
+  M as useXFormField,
+  q as useXFormFieldContext,
+  H as useXFormItem,
+  X as validateFieldValue,
+  U as validateFields
+};

package/dist/composables/i18n.d.ts

@@ -1,5 +1,6 @@
 import { ComputedRef, MaybeRefOrGetter } from 'vue';
 import { arEG } from '../locales/ar-EG';
+import { daDK } from '../locales/da-DK';
 import { deDE } from '../locales/de-DE';
 import { enUS } from '../locales/en-US';
 import { esES } from '../locales/es-ES';
@@ -10,14 +11,15 @@ import { jaJP } from '../locales/ja-JP';
 import { kmKH } from '../locales/km-KH';
 import { koKR } from '../locales/ko-KR';
 import { msMY } from '../locales/ms-MY';
+import { nlNL } from '../locales/nl-NL';
 import { ptPT } from '../locales/pt-PT';
 import { ruRU } from '../locales/ru-RU';
 import { thTH } from '../locales/th-TH';
 import { viVN } from '../locales/vi-VN';
 import { zhCN } from '../locales/zh-CN';
 import { zhTW } from '../locales/zh-TW';
-export { arEG, deDE, enUS, esES, frFR, idID, itIT, jaJP, kmKH, koKR, msMY, ptPT, ruRU, thTH, viVN, zhCN, zhTW, };
-export declare const supportedXLocales: readonly ["zh-CN", "en-US", "ja-JP", "zh-TW", "pt-PT", "es-ES", "id-ID", "fr-FR", "de-DE", "ko-KR", "it-IT", "ms-MY", "th-TH", "vi-VN", "km-KH", "ar-EG", "ru-RU"];
+export { arEG, daDK, deDE, enUS, esES, frFR, idID, itIT, jaJP, kmKH, koKR, msMY, nlNL, ptPT, ruRU, thTH, viVN, zhCN, zhTW, };
+export declare const supportedXLocales: readonly ["zh-CN", "en-US", "ja-JP", "zh-TW", "pt-PT", "es-ES", "id-ID", "fr-FR", "da-DK", "de-DE", "ko-KR", "it-IT", "ms-MY", "nl-NL", "th-TH", "vi-VN", "km-KH", "ar-EG", "ru-RU"];
 export type XSupportedLocale = (typeof supportedXLocales)[number];
 export type XLocale = XSupportedLocale | (string & {});
 export type XI18nParamValue = string | number | boolean | null | undefined;

package/dist/composables/i18n.js

@@ -0,0 +1,257 @@
+import { inject as C, provide as b, computed as f, toValue as T, ref as D } from "vue";
+import { arEG as W } from "../locales/ar-EG.js";
+import { daDK as y } from "../locales/da-DK.js";
+import { deDE as A } from "../locales/de-DE.js";
+import { enUS as V } from "../locales/en-US.js";
+import { esES as w } from "../locales/es-ES.js";
+import { frFR as x } from "../locales/fr-FR.js";
+import { idID as F } from "../locales/id-ID.js";
+import { itIT as G } from "../locales/it-IT.js";
+import { jaJP as B } from "../locales/ja-JP.js";
+import { kmKH as J } from "../locales/km-KH.js";
+import { koKR as Y } from "../locales/ko-KR.js";
+import { msMY as X } from "../locales/ms-MY.js";
+import { nlNL as O } from "../locales/nl-NL.js";
+import { ptPT as _ } from "../locales/pt-PT.js";
+import { ruRU as q } from "../locales/ru-RU.js";
+import { thTH as Q } from "../locales/th-TH.js";
+import { viVN as Z } from "../locales/vi-VN.js";
+import { zhCN as $ } from "../locales/zh-CN.js";
+import { zhTW as tt } from "../locales/zh-TW.js";
+const Dt = [
+  "zh-CN",
+  "en-US",
+  "ja-JP",
+  "zh-TW",
+  "pt-PT",
+  "es-ES",
+  "id-ID",
+  "fr-FR",
+  "da-DK",
+  "de-DE",
+  "ko-KR",
+  "it-IT",
+  "ms-MY",
+  "nl-NL",
+  "th-TH",
+  "vi-VN",
+  "km-KH",
+  "ar-EG",
+  "ru-RU"
+], d = "zh-CN", g = {
+  "ar-EG": W,
+  "da-DK": y,
+  "de-DE": A,
+  "en-US": V,
+  "es-ES": w,
+  "fr-FR": x,
+  "id-ID": F,
+  "it-IT": G,
+  "ja-JP": B,
+  "km-KH": J,
+  "ko-KR": Y,
+  "ms-MY": X,
+  "nl-NL": O,
+  "pt-PT": _,
+  "ru-RU": q,
+  "th-TH": Q,
+  "vi-VN": Z,
+  "zh-CN": $,
+  "zh-TW": tt
+}, l = {
+  ar: "ar-EG",
+  "ar-eg": "ar-EG",
+  da: "da-DK",
+  "da-dk": "da-DK",
+  de: "de-DE",
+  "de-de": "de-DE",
+  en: "en-US",
+  "en-gb": "en-US",
+  "en-us": "en-US",
+  es: "es-ES",
+  "es-es": "es-ES",
+  fr: "fr-FR",
+  "fr-fr": "fr-FR",
+  id: "id-ID",
+  "id-id": "id-ID",
+  it: "it-IT",
+  "it-it": "it-IT",
+  ja: "ja-JP",
+  "ja-jp": "ja-JP",
+  km: "km-KH",
+  "km-kh": "km-KH",
+  ko: "ko-KR",
+  "ko-kr": "ko-KR",
+  ms: "ms-MY",
+  "ms-my": "ms-MY",
+  nl: "nl-NL",
+  "nl-nl": "nl-NL",
+  pt: "pt-PT",
+  "pt-pt": "pt-PT",
+  ru: "ru-RU",
+  "ru-ru": "ru-RU",
+  th: "th-TH",
+  "th-th": "th-TH",
+  vi: "vi-VN",
+  "vi-vn": "vi-VN",
+  zh: "zh-CN",
+  "zh-cn": "zh-CN",
+  "zh-hans": "zh-CN",
+  "zh-hans-cn": "zh-CN",
+  "zh-my": "zh-CN",
+  "zh-sg": "zh-CN",
+  "zh-hant": "zh-TW",
+  "zh-hant-tw": "zh-TW",
+  "zh-hk": "zh-TW",
+  "zh-mo": "zh-TW",
+  "zh-tw": "zh-TW"
+}, S = D(d), L = D({}), j = D(void 0), I = Symbol("x-i18n");
+function z(t) {
+  return !!t && typeof t == "object" && !Array.isArray(t);
+}
+function rt(t) {
+  return t in g;
+}
+function p(t) {
+  if (Array.isArray(t))
+    return t.map((n) => p(n));
+  if (z(t)) {
+    const n = {};
+    return Object.entries(t).forEach(([e, r]) => {
+      n[e] = p(r);
+    }), n;
+  }
+  return t;
+}
+function h(t, n) {
+  const e = p(t);
+  return n && Object.entries(n).forEach(([r, o]) => {
+    const i = e[r];
+    if (z(i) && z(o)) {
+      e[r] = h(i, o);
+      return;
+    }
+    e[r] = p(o);
+  }), e;
+}
+function nt(t) {
+  const n = t.trim();
+  if (!n) return d;
+  if (n in g) return n;
+  const e = n.replace(/_/g, "-");
+  if (e in g) return e;
+  const r = e.toLowerCase();
+  if (l[r]) return l[r];
+  const o = r.split("-")[0];
+  return l[o] ? l[o] : e;
+}
+function N(t) {
+  const n = nt(t);
+  return rt(n) ? g[n] : {};
+}
+function m(t, n) {
+  if (!n) return t;
+  const e = n.split(".").filter(Boolean);
+  let r = t;
+  for (const o of e) {
+    if (!z(r) || !(o in r))
+      return;
+    r = r[o];
+  }
+  return r;
+}
+function E(t, n) {
+  return n ? t.replace(/\{([^{}]+)\}/g, (e, r) => {
+    const o = r.trim(), i = n[o];
+    return i == null ? "" : String(i);
+  }) : t;
+}
+function U(t, n, e, r) {
+  const o = f(() => T(t) ?? (r == null ? void 0 : r.locale.value) ?? S.value), i = f(() => {
+    const s = T(n) ?? {};
+    if (r)
+      return h(r.messages.value, s);
+    const u = N(o.value), a = h(u, L.value);
+    return h(a, s);
+  }), K = f(() => T(e) ?? (r == null ? void 0 : r.translate.value) ?? j.value);
+  function k(s, u, a) {
+    const c = K.value;
+    if (c) {
+      const v = c(s, {
+        locale: o.value,
+        messages: i.value,
+        params: u,
+        fallback: a
+      });
+      if (typeof v == "string" && v.length > 0)
+        return v;
+    }
+    const R = m(i.value, s);
+    if (typeof R == "string")
+      return E(R, u);
+    const M = m(N(d), s);
+    return typeof M == "string" ? E(M, u) : a !== void 0 ? E(a, u) : s;
+  }
+  function H(s, u) {
+    const a = m(i.value, s);
+    if (a !== void 0)
+      return a;
+    const c = m(N(d), s);
+    return c !== void 0 ? c : u;
+  }
+  return {
+    locale: o,
+    messages: i,
+    translate: K,
+    t: k,
+    tm: H
+  };
+}
+const P = U(
+  f(() => {
+  }),
+  f(() => {
+  }),
+  f(() => {
+  }),
+  null
+);
+function Kt(t = {}) {
+  t.locale !== void 0 && (S.value = t.locale), t.messages !== void 0 && (L.value = t.messages), "translate" in t && (j.value = t.translate);
+}
+function Rt(t, n, e) {
+  const r = C(I, null), o = U(t, n, e, r);
+  return b(I, o), o;
+}
+function Mt() {
+  return C(I, P);
+}
+function Ct(t, n, e) {
+  return P.t(t, n, e);
+}
+export {
+  W as arEG,
+  Kt as configureXI18n,
+  y as daDK,
+  A as deDE,
+  V as enUS,
+  w as esES,
+  x as frFR,
+  F as idID,
+  G as itIT,
+  B as jaJP,
+  J as kmKH,
+  Y as koKR,
+  X as msMY,
+  O as nlNL,
+  Rt as provideXI18n,
+  _ as ptPT,
+  q as ruRU,
+  Dt as supportedXLocales,
+  Ct as tI18n,
+  Q as thTH,
+  Mt as useXI18n,
+  Z as viVN,
+  $ as zhCN,
+  tt as zhTW
+};

package/dist/composables/menu-context.js

@@ -0,0 +1,6 @@
+const e = Symbol("MenuInjectionKey"), n = Symbol("LevelInjectionKey"), o = Symbol("DataCollectorInjectionKey");
+export {
+  o as DataCollectorInjectionKey,
+  n as LevelInjectionKey,
+  e as MenuInjectionKey
+};

package/dist/composables/menu-hooks/use-level.js

@@ -0,0 +1,25 @@
+import { inject as r, computed as n, isRef as l, provide as u, reactive as p } from "vue";
+import { LevelInjectionKey as i } from "../menu-context.js";
+function s(e) {
+  const o = n(() => l(e) ? e.value : e);
+  u(
+    i,
+    p({
+      level: o
+    })
+  );
+}
+function m(e) {
+  const { provideNextLevel: o } = e || {}, t = r(i), c = n(() => (t == null ? void 0 : t.level) || 1);
+  if (o) {
+    const v = n(() => c.value + 1);
+    s(v);
+  }
+  return {
+    level: c
+  };
+}
+export {
+  m as default,
+  s as provideLevel
+};