@rhino-design/vue 0.2.1 → 0.2.3

package/dist/components/x-checkbox-context.d.ts

@@ -0,0 +1,19 @@
+import { ComputedRef, InjectionKey, Slot, VNodeChild } from 'vue';
+export type XCheckboxValue = string | number | boolean;
+export type XCheckboxDirection = 'horizontal' | 'vertical';
+export type XCheckboxOptionLabel = string | number | (() => VNodeChild);
+export interface XCheckboxOption {
+    label?: XCheckboxOptionLabel;
+    value: string | number;
+    disabled?: boolean;
+    indeterminate?: boolean;
+}
+export interface XCheckboxGroupContext {
+    name: 'XCheckboxGroup';
+    computedValue: ComputedRef<XCheckboxValue[]>;
+    disabled: ComputedRef<boolean>;
+    isMaxed: ComputedRef<boolean>;
+    checkboxSlot?: Slot;
+    handleChange: (value: XCheckboxValue[], ev: Event) => void;
+}
+export declare const xCheckboxGroupKey: InjectionKey<XCheckboxGroupContext>;

package/dist/components/x-checkbox-context.js

@@ -0,0 +1,4 @@
+const o = Symbol("XCheckboxGroup");
+export {
+  o as xCheckboxGroupKey
+};

package/dist/components/x-dropdown-context.d.ts

@@ -0,0 +1,7 @@
+import { InjectionKey, Ref } from 'vue';
+export type XDropdownValue = string | number | Record<string, any> | undefined;
+export interface XDropdownContext {
+    popupMaxHeight: Ref<boolean | number>;
+    onOptionClick: (value: XDropdownValue, event: Event) => void;
+}
+export declare const xDropdownInjectionKey: InjectionKey<XDropdownContext>;

package/dist/components/x-dropdown-context.js

@@ -0,0 +1,4 @@
+const o = Symbol("x-dropdown-context");
+export {
+  o as xDropdownInjectionKey
+};

package/dist/components/x-icon-shared.d.ts

@@ -61,9 +61,9 @@ export declare function createXIconComponent(componentName: string): import('vue
         default: boolean;
     };
 }>> & Readonly<{}>, {
+    size: string | number;
     color: string;
     strokeWidth: string | number;
-    size: string | number;
     spin: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export {};

package/dist/components/x-icon-shared.js

@@ -0,0 +1,151 @@
+import { defineComponent as h, ref as p, watch as y, computed as g, h as m } from "vue";
+import { internalIconDefinitions as v } from "../iconfont/internal-icons.js";
+const o = /* @__PURE__ */ new Map(), s = /* @__PURE__ */ new Map();
+let c = !1;
+function w() {
+  if (typeof document > "u")
+    return;
+  const e = "x-icon-spin-style";
+  if (document.getElementById(e))
+    return;
+  const t = document.createElement("style");
+  t.id = e, t.textContent = `
+    @keyframes x-icon-spin {
+      from { transform: rotate(0deg); }
+      to { transform: rotate(360deg); }
+    }
+  `, document.head.appendChild(t);
+}
+function u() {
+  c || (c = !0, v.forEach((e) => {
+    o.set(e.name, {
+      viewBox: e.viewBox,
+      content: e.content
+    });
+  }));
+}
+w();
+u();
+const b = {
+  register(e, t) {
+    o.set(e, t);
+  },
+  registerMultiple(e) {
+    Object.entries(e).forEach(([t, n]) => {
+      o.set(t, n);
+    });
+  },
+  has(e) {
+    return o.has(e);
+  },
+  get(e) {
+    return o.get(e);
+  },
+  clear(e) {
+    o.clear(), (e == null ? void 0 : e.keepInternal) !== !1 && (c = !1, u());
+  }
+}, C = {
+  register(e, t) {
+    s.set(e, t);
+  },
+  registerMultiple(e) {
+    Object.entries(e).forEach(([t, n]) => {
+      s.set(t, n);
+    });
+  },
+  has(e) {
+    return s.has(e);
+  },
+  clear() {
+    s.clear();
+  }
+};
+function x(e, t) {
+  let n = e.replace(/\b(fill|stroke)="([^"]+)"/g, (f, l) => `${l}="currentColor"`);
+  return n = n.replace(/<path(?![^>]*\bfill=)/g, '<path fill="currentColor"'), n = n.replace(/<path(?![^>]*\bstroke-width=)/g, `<path stroke-width="${t}"`), n;
+}
+function S(e) {
+  return h({
+    name: e,
+    props: {
+      name: {
+        type: String,
+        required: !0
+      },
+      size: {
+        type: [String, Number],
+        default: "1em"
+      },
+      color: {
+        type: String,
+        default: "currentColor"
+      },
+      strokeWidth: {
+        type: [String, Number],
+        default: 4
+      },
+      spin: {
+        type: Boolean,
+        default: !1
+      }
+    },
+    setup(t) {
+      const n = p(null), f = async (r) => {
+        if (u(), o.has(r)) {
+          n.value = o.get(r) ?? null;
+          return;
+        }
+        const a = s.get(r);
+        if (!a) {
+          n.value = null;
+          return;
+        }
+        try {
+          const i = await a();
+          o.set(r, i), n.value = i;
+        } catch (i) {
+          console.error(`Failed to load icon: ${r}`, i), n.value = null;
+        }
+      };
+      y(
+        () => t.name,
+        (r) => {
+          f(r);
+        },
+        { immediate: !0 }
+      );
+      const l = g(() => {
+        if (!n.value)
+          return "";
+        const { viewBox: r, content: a } = n.value, i = typeof t.strokeWidth == "number" ? t.strokeWidth : parseFloat(t.strokeWidth) || 4;
+        return `<svg viewBox="${r}" xmlns="http://www.w3.org/2000/svg">${x(a, i)}</svg>`;
+      }), d = g(() => {
+        const r = typeof t.size == "number" ? `${t.size}px` : t.size;
+        return {
+          fontSize: r,
+          color: t.color,
+          display: "inline-flex",
+          alignItems: "center",
+          justifyContent: "center",
+          width: r,
+          height: r,
+          animation: t.spin ? "x-icon-spin 1s linear infinite" : void 0,
+          transformOrigin: "center center"
+        };
+      });
+      return () => l.value ? m("span", {
+        class: "x-icon",
+        style: d.value,
+        innerHTML: l.value
+      }) : m("span", {
+        class: "x-icon x-icon--empty",
+        style: d.value
+      });
+    }
+  });
+}
+export {
+  C as XIconLoaders,
+  b as XIconRegistry,
+  S as createXIconComponent
+};

package/dist/components/x-list-shared.d.ts

@@ -1,6 +1,13 @@
 import { ComputedRef, InjectionKey } from 'vue';
 export type XListSize = 'small' | 'medium' | 'large';
 export type XListActionLayout = 'horizontal' | 'vertical';
+export type XListGridResponsiveValue = number | {
+    span?: number;
+    offset?: number;
+    order?: number;
+    push?: number;
+    pull?: number;
+};
 export interface XListPaginationProps {
     current?: number;
     defaultCurrent?: number;
@@ -15,19 +22,24 @@ export interface XListPaginationProps {
     size?: 'mini' | 'small' | 'medium';
 }
 export interface XListGridProps {
-    cols?: number;
     gutter?: number | [number, number];
-    xs?: number;
-    sm?: number;
-    md?: number;
-    lg?: number;
-    xl?: number;
-    xxl?: number;
+    span?: number;
+    offset?: number;
+    order?: number;
+    push?: number;
+    pull?: number;
+    xs?: XListGridResponsiveValue;
+    sm?: XListGridResponsiveValue;
+    md?: XListGridResponsiveValue;
+    lg?: XListGridResponsiveValue;
+    xl?: XListGridResponsiveValue;
+    xxl?: XListGridResponsiveValue;
+    xxxl?: XListGridResponsiveValue;
 }
 export interface XListVirtualListProps {
     height?: string | number;
     threshold?: number;
-    fixedSize?: number;
+    fixedSize?: boolean;
     estimatedSize?: number;
     buffer?: number;
     isStaticItemHeight?: boolean;

package/dist/components/x-radio-context.js

@@ -0,0 +1,4 @@
+const o = Symbol("XRadioGroup");
+export {
+  o as xRadioGroupKey
+};

package/dist/components/x-scrollbar-types.d.ts

@@ -0,0 +1,5 @@
+export interface XScrollbarThumbData {
+    ratio: number;
+    thumbSize: number;
+    max: number;
+}

package/dist/composables/collapse.d.ts

@@ -1,10 +1,13 @@
-import { ComputedRef, InjectionKey } from 'vue';
+import { ComputedRef, InjectionKey, Slots } from 'vue';
 export type XCollapseKey = string | number;
+export type XCollapseExpandIconPosition = 'left' | 'right';
 export interface XCollapseContext {
-    accordion: ComputedRef<boolean>;
-    bordered: ComputedRef<boolean>;
-    isActive: (key: XCollapseKey) => boolean;
-    toggle: (key: XCollapseKey) => void;
+    activeKeys: ComputedRef<XCollapseKey[]>;
+    slots: Slots;
+    showExpandIcon: ComputedRef<boolean | undefined>;
+    expandIconPosition: ComputedRef<XCollapseExpandIconPosition>;
+    destroyOnHide: ComputedRef<boolean>;
+    handleClick: (key: XCollapseKey, event: MouseEvent | KeyboardEvent) => void;
 }
 export declare const xCollapseKey: InjectionKey<XCollapseContext>;
 export declare function useXCollapse(): XCollapseContext | null;

package/dist/composables/collapse.js

@@ -0,0 +1,9 @@
+import { inject as l } from "vue";
+const o = Symbol("x-collapse");
+function n() {
+  return l(o, null);
+}
+export {
+  n as useXCollapse,
+  o as xCollapseKey
+};

package/dist/composables/config-provider.d.ts

@@ -0,0 +1,29 @@
+import { InjectionKey, MaybeRefOrGetter, Ref, Slots, VNode } from 'vue';
+import { XSize } from './config';
+export type XConfigProviderLocale = string | Record<string, unknown>;
+export interface XConfigProviderContext {
+    slots: Slots;
+    prefixCls: Ref<string>;
+    locale?: Ref<XConfigProviderLocale | undefined>;
+    size?: Ref<XSize | undefined>;
+    updateAtScroll: Ref<boolean>;
+    scrollToClose: Ref<boolean>;
+    exchangeTime: Ref<boolean>;
+    rtl: Ref<boolean>;
+}
+interface XConfigProviderProps {
+    prefixCls: string;
+    locale?: XConfigProviderLocale;
+    size?: XSize;
+    global?: boolean;
+    updateAtScroll: boolean;
+    scrollToClose: boolean;
+    exchangeTime: boolean;
+    rtl: boolean;
+}
+export declare const xConfigProviderInjectionKey: InjectionKey<XConfigProviderContext>;
+export declare function provideXConfigProvider(props: XConfigProviderProps, slots: Slots): XConfigProviderContext;
+export declare function useXConfigProvider(): XConfigProviderContext | undefined;
+export type XConfigProviderSlotRenderer = (() => VNode[]) | null;
+export declare function useXConfigProviderSlotRender(slotName: string, slotProps?: MaybeRefOrGetter<Record<string, unknown> | undefined>): import('vue').ComputedRef<XConfigProviderSlotRenderer>;
+export {};

package/dist/composables/config-provider.js

@@ -0,0 +1,48 @@
+import { inject as a, computed as p, toValue as g, toRefs as v, getCurrentInstance as C, provide as m } from "vue";
+const c = Symbol("XConfigProvider");
+function P(n, i) {
+  const {
+    prefixCls: e,
+    locale: r,
+    size: o,
+    updateAtScroll: t,
+    scrollToClose: u,
+    exchangeTime: f,
+    rtl: d
+  } = v(n), l = {
+    slots: i,
+    prefixCls: e,
+    locale: r,
+    size: o,
+    updateAtScroll: t,
+    scrollToClose: u,
+    exchangeTime: f,
+    rtl: d
+  };
+  if (n.global) {
+    const s = C();
+    s && s.appContext.app.provide(c, l);
+  } else
+    m(c, l);
+  return l;
+}
+function x() {
+  return a(c, void 0);
+}
+function X(n, i) {
+  const e = x();
+  return p(() => {
+    var t;
+    const r = (t = e == null ? void 0 : e.slots) == null ? void 0 : t[n];
+    if (typeof r != "function")
+      return null;
+    const o = r(g(i));
+    return !Array.isArray(o) || o.length === 0 ? null : () => o;
+  });
+}
+export {
+  P as provideXConfigProvider,
+  x as useXConfigProvider,
+  X as useXConfigProviderSlotRender,
+  c as xConfigProviderInjectionKey
+};

package/dist/composables/config.js

@@ -0,0 +1,39 @@
+import { inject as t, computed as r, ref as d, toValue as n, provide as x } from "vue";
+const i = {
+  colorPrimary: "#409eff",
+  colorPrimaryHover: "#0e42d2",
+  colorText: "#303133",
+  colorTextSecondary: "#606266",
+  colorDanger: "#f56c6c",
+  colorBorder: "#dcdfe6",
+  colorFill: "#f0f2f5",
+  colorSurface: "#ffffff",
+  colorSurfaceRaised: "#f7f8fa",
+  shadowCard: "0 18px 40px rgba(15, 23, 42, 0.08)",
+  shadowPopup: "0 20px 50px rgba(15, 23, 42, 0.16)",
+  borderRadius: "16px",
+  fontSize: "14px"
+}, c = Symbol("x-config");
+function p(o, l) {
+  const e = t(c, null), s = d("medium"), u = r(() => n(o) ?? (e == null ? void 0 : e.size.value) ?? s.value), a = r(() => ({
+    ...(e == null ? void 0 : e.tokens.value) ?? i,
+    ...n(l)
+  })), f = { size: u, tokens: a };
+  return x(c, f), f;
+}
+function g() {
+  const o = t(c, null);
+  return o || {
+    size: r(() => "medium"),
+    tokens: r(() => i)
+  };
+}
+function v(o) {
+  return o ? `x-size-${o}` : "";
+}
+export {
+  i as defaultTokens,
+  p as provideXConfig,
+  v as sizeClass,
+  g as useXConfig
+};