3h1-ui 3.0.0-next.22 → 3.0.0-next.220

package/es/ui/src/ColorPickerPopover/src/vue-colorful/components/common/Alpha.d.ts

@@ -0,0 +1,27 @@
+import type { PropType } from 'vue';
+import type { HsvaColor } from '../../types';
+export interface AlphaProps {
+    hsva: HsvaColor;
+    onChange: (newAlpha: {
+        a: number;
+    }) => void;
+}
+export declare const Alpha: import("vue").DefineComponent<{
+    hsva: {
+        type: PropType<HsvaColor>;
+    };
+    onChange: {
+        type: PropType<(newAlpha: {
+            a: number;
+        }) => void>;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    hsva: {
+        type: PropType<HsvaColor>;
+    };
+    onChange: {
+        type: PropType<(newAlpha: {
+            a: number;
+        }) => void>;
+    };
+}>>, {}, {}>;

package/es/ui/src/ColorPickerPopover/src/vue-colorful/components/common/AlphaColorPicker.d.ts

@@ -0,0 +1,26 @@
+import type { PropType } from 'vue';
+import type { ColorModel, ColorPickerBaseProps, AnyColor } from '../../types';
+export interface AlphaColorPickerProps<T extends AnyColor> extends Partial<ColorPickerBaseProps<T>> {
+    colorModel: ColorModel<T>;
+}
+export declare const AlphaColorPicker: import("vue").DefineComponent<{
+    colorModel: {
+        type: PropType<ColorModel<AnyColor>>;
+    };
+    color: {
+        type: PropType<AnyColor>;
+    };
+    onChange: {
+        type: PropType<(newColor: AnyColor) => void>;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    colorModel: {
+        type: PropType<ColorModel<AnyColor>>;
+    };
+    color: {
+        type: PropType<AnyColor>;
+    };
+    onChange: {
+        type: PropType<(newColor: AnyColor) => void>;
+    };
+}>>, {}, {}>;

package/es/ui/src/ColorPickerPopover/src/vue-colorful/components/common/ColorPicker.d.ts

@@ -0,0 +1,26 @@
+import type { PropType } from 'vue';
+import type { ColorModel, ColorPickerBaseProps, AnyColor } from '../../types';
+export interface ColorPickerProps<T extends AnyColor> extends Partial<ColorPickerBaseProps<T>> {
+    colorModel: ColorModel<T>;
+}
+export declare const ColorPicker: import("vue").DefineComponent<{
+    colorModel: {
+        type: PropType<ColorModel<AnyColor>>;
+    };
+    color: {
+        type: PropType<AnyColor>;
+    };
+    onChange: {
+        type: PropType<(newColor: AnyColor) => void>;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    colorModel: {
+        type: PropType<ColorModel<AnyColor>>;
+    };
+    color: {
+        type: PropType<AnyColor>;
+    };
+    onChange: {
+        type: PropType<(newColor: AnyColor) => void>;
+    };
+}>>, {}, {}>;

package/es/ui/src/ColorPickerPopover/src/vue-colorful/components/common/Hue.d.ts

@@ -0,0 +1,27 @@
+import type { PropType } from 'vue';
+export interface Props {
+    className?: string;
+    hue: number;
+    onChange: (newHue: {
+        h: number;
+    }) => void;
+}
+export declare const Hue: import("vue").DefineComponent<{
+    hue: {
+        type: NumberConstructor;
+    };
+    onChange: {
+        type: PropType<(newHue: {
+            h: number;
+        }) => void>;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    hue: {
+        type: NumberConstructor;
+    };
+    onChange: {
+        type: PropType<(newHue: {
+            h: number;
+        }) => void>;
+    };
+}>>, {}, {}>;

package/es/ui/src/ColorPickerPopover/src/vue-colorful/components/common/Interactive.d.ts

@@ -0,0 +1,24 @@
+import type { PropType } from 'vue';
+export interface Interaction {
+    left: number;
+    top: number;
+}
+export interface InteractiveProps {
+    onMove: (interaction: Interaction) => void;
+    onKey: (offset: Interaction) => void;
+}
+export declare const Interactive: import("vue").DefineComponent<{
+    onMove: {
+        type: PropType<(interaction: Interaction) => void>;
+    };
+    onKey: {
+        type: PropType<(offset: Interaction) => void>;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    onMove: {
+        type: PropType<(interaction: Interaction) => void>;
+    };
+    onKey: {
+        type: PropType<(offset: Interaction) => void>;
+    };
+}>>, {}, {}>;

package/es/ui/src/ColorPickerPopover/src/vue-colorful/components/common/Pointer.d.ts

@@ -0,0 +1,30 @@
+export interface PointerProps {
+    top?: number;
+    left: number;
+    color: string;
+}
+export declare const Pointer: import("vue").DefineComponent<{
+    top: {
+        type: NumberConstructor;
+        default: number;
+    };
+    left: {
+        type: NumberConstructor;
+    };
+    color: {
+        type: StringConstructor;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    top: {
+        type: NumberConstructor;
+        default: number;
+    };
+    left: {
+        type: NumberConstructor;
+    };
+    color: {
+        type: StringConstructor;
+    };
+}>>, {
+    top: number;
+}, {}>;

package/es/ui/src/ColorPickerPopover/src/vue-colorful/components/common/Saturation.d.ts

@@ -0,0 +1,30 @@
+import type { PropType } from 'vue';
+import type { HsvaColor } from '../../types';
+export interface SaturationProps {
+    hsva: HsvaColor;
+    onChange: (newColor: {
+        s: number;
+        v: number;
+    }) => void;
+}
+export declare const Saturation: import("vue").DefineComponent<{
+    hsva: {
+        type: PropType<HsvaColor>;
+    };
+    onChange: {
+        type: PropType<(newColor: {
+            s: number;
+            v: number;
+        }) => void>;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    hsva: {
+        type: PropType<HsvaColor>;
+    };
+    onChange: {
+        type: PropType<(newColor: {
+            s: number;
+            v: number;
+        }) => void>;
+    };
+}>>, {}, {}>;

package/es/ui/src/ColorPickerPopover/src/vue-colorful/css/styles.css.d.ts

@@ -0,0 +1,2 @@
+declare const cssString: string;
+export default cssString;

package/es/ui/src/ColorPickerPopover/src/vue-colorful/hooks/useEventCallback.d.ts

@@ -0,0 +1 @@
+export declare function useEventCallback<T>(handler?: (value: T) => void): (value: T) => void;

package/es/ui/src/ColorPickerPopover/src/vue-colorful/hooks/useStyleSheet.d.ts

@@ -0,0 +1,5 @@
+import type { Ref } from 'vue';
+/**
+ * Injects CSS code into the document's <head>
+ */
+export declare const useStyleSheet: (nodeRef: Ref<HTMLDivElement>) => void;

package/es/ui/src/ColorPickerPopover/src/vue-colorful/index.d.ts

@@ -0,0 +1,2 @@
+export { HexColorPicker } from './components/HexColorPicker';
+export { RgbaColorPicker } from './components/RgbaColorPicker';

package/es/ui/src/ColorPickerPopover/src/vue-colorful/types.d.ts

@@ -0,0 +1,44 @@
+import type { InputHTMLAttributes } from 'vue';
+export interface RgbColor {
+    r: number;
+    g: number;
+    b: number;
+}
+export interface RgbaColor extends RgbColor {
+    a: number;
+}
+export interface HslColor {
+    h: number;
+    s: number;
+    l: number;
+}
+export interface HslaColor extends HslColor {
+    a: number;
+}
+export interface HsvColor {
+    h: number;
+    s: number;
+    v: number;
+}
+export interface HsvaColor extends HsvColor {
+    a: number;
+}
+export type ObjectColor = RgbColor | HslColor | HsvColor | RgbaColor | HslaColor | HsvaColor;
+export type AnyColor = string | ObjectColor;
+export interface ColorModel<T extends AnyColor> {
+    defaultColor: T;
+    toHsva: (defaultColor: T) => HsvaColor;
+    fromHsva: (hsva: HsvaColor) => T;
+    equal: (first: T, second: T) => boolean;
+}
+type ColorPickerHTMLAttributes = Omit<InputHTMLAttributes, 'color' | 'onChange' | 'onChangeCapture'>;
+export interface ColorPickerBaseProps<T extends AnyColor> extends ColorPickerHTMLAttributes {
+    color: T;
+    onChange: (newColor: T) => void;
+}
+type ColorInputHTMLAttributes = Omit<InputHTMLAttributes, 'onChange' | 'value'>;
+export interface ColorInputBaseProps extends ColorInputHTMLAttributes {
+    color?: string;
+    onChange?: (newColor: string) => void;
+}
+export {};

package/es/ui/src/ColorPickerPopover/src/vue-colorful/utils/clamp.d.ts

@@ -0,0 +1 @@
+export declare const clamp: (number: number, min?: number, max?: number) => number;

package/es/ui/src/ColorPickerPopover/src/vue-colorful/utils/compare.d.ts

@@ -0,0 +1,4 @@
+import type { ObjectColor } from '../types';
+export declare const equalColorObjects: (first: ObjectColor, second: ObjectColor) => boolean;
+export declare const equalColorString: (first: string, second: string) => boolean;
+export declare const equalHex: (first: string, second: string) => boolean;

package/es/ui/src/ColorPickerPopover/src/vue-colorful/utils/convert.d.ts

@@ -0,0 +1,26 @@
+import type { RgbaColor, RgbColor, HslaColor, HslColor, HsvaColor, HsvColor } from '../types';
+export declare const hexToHsva: (hex: string) => HsvaColor;
+export declare const hexToRgba: (hex: string) => RgbaColor;
+export declare const parseHue: (value: string, unit?: string) => number;
+export declare const hslaStringToHsva: (hslString: string) => HsvaColor;
+export declare const hslStringToHsva: (hslString: string) => HsvaColor;
+export declare const hslaToHsva: ({ h, s, l, a }: HslaColor) => HsvaColor;
+export declare const hsvaToHex: (hsva: HsvaColor) => string;
+export declare const hsvaToHsla: ({ h, s, v, a }: HsvaColor) => HslaColor;
+export declare const hsvaToHslString: (hsva: HsvaColor) => string;
+export declare const hsvaToHsvString: (hsva: HsvaColor) => string;
+export declare const hsvaToHsvaString: (hsva: HsvaColor) => string;
+export declare const hsvaToHslaString: (hsva: HsvaColor) => string;
+export declare const hsvaToRgba: ({ h, s, v, a }: HsvaColor) => RgbaColor;
+export declare const hsvaToRgbString: (hsva: HsvaColor) => string;
+export declare const hsvaToRgbaString: (hsva: HsvaColor) => string;
+export declare const hsvaStringToHsva: (hsvString: string) => HsvaColor;
+export declare const hsvStringToHsva: (hsvString: string) => HsvaColor;
+export declare const rgbaStringToHsva: (rgbaString: string) => HsvaColor;
+export declare const rgbStringToHsva: (rgbaString: string) => HsvaColor;
+export declare const rgbaToHex: ({ r, g, b, a }: RgbaColor) => string;
+export declare const rgbaToHsva: ({ r, g, b, a }: RgbaColor) => HsvaColor;
+export declare const roundHsva: (hsva: HsvaColor) => HsvaColor;
+export declare const rgbaToRgb: ({ r, g, b }: RgbaColor) => RgbColor;
+export declare const hslaToHsl: ({ h, s, l }: HslaColor) => HslColor;
+export declare const hsvaToHsv: (hsva: HsvaColor) => HsvColor;

package/es/ui/src/ColorPickerPopover/src/vue-colorful/utils/format.d.ts

@@ -0,0 +1 @@
+export declare const formatClassName: (names: unknown[]) => string;

package/es/ui/src/ColorPickerPopover/src/vue-colorful/utils/nonce.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Returns a nonce hash included by Webpack or the one defined manually by developer.
+ * https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/nonce
+ * https://webpack.js.org/guides/csp/
+ */
+export declare const getNonce: () => string | undefined;
+/**
+ * Signs the style tag with a base64-encoded string (nonce) to conforms to Content Security Policies.
+ * This function has to be invoked before any picker is rendered if you aren't using Webpack for CSP.
+ */
+export declare const setNonce: (hash: string) => void;

package/es/ui/src/ColorPickerPopover/src/vue-colorful/utils/round.d.ts

@@ -0,0 +1 @@
+export declare const round: (number: number, digits?: number, base?: number) => number;

package/es/ui/src/Container/index.d.ts

@@ -0,0 +1,5 @@
+import CollapseContainer from './src/collapse/CollapseContainer.vue';
+import ScrollContainer from './src/ScrollContainer.vue';
+import LazyContainer from './src/LazyContainer.vue';
+export { LazyContainer, ScrollContainer, CollapseContainer };
+export * from './src/typing';

package/es/ui/src/Container/src/LazyContainer.vue.d.ts

@@ -0,0 +1,121 @@
+import type { PropType } from 'vue';
+declare const _sfc_main: import("vue").DefineComponent<{
+    /**
+     * Waiting time, if the time is specified, whether visible or not, it will be automatically loaded after the specified time
+     */
+    timeout: {
+        type: NumberConstructor;
+    };
+    /**
+     * The viewport where the component is located.
+     * If the component is scrolling in the page container, the viewport is the container
+     */
+    viewport: {
+        type: PropType<HTMLElement>;
+        default: () => any;
+    };
+    /**
+     * Preload threshold, css unit
+     */
+    threshold: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * The scroll direction of the viewport, vertical represents the vertical direction, horizontal represents the horizontal direction
+     */
+    direction: {
+        type: StringConstructor;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    /**
+     * The label name of the outer container that wraps the component
+     */
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    maxWaitingTime: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /**
+     * transition name
+     */
+    transitionName: {
+        type: StringConstructor;
+        default: string;
+    };
+}, {
+    isInit: import("vue").Ref<boolean>;
+    loading: import("vue").Ref<boolean>;
+    intersectionObserverInstance: import("vue").Ref<{
+        readonly root: Document | Element;
+        readonly rootMargin: string;
+        readonly thresholds: readonly number[];
+        disconnect: () => void;
+        observe: (target: Element) => void;
+        takeRecords: () => IntersectionObserverEntry[];
+        unobserve: (target: Element) => void;
+    }>;
+    elRef: import("vue").Ref<any>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, "init"[], "init", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    /**
+     * Waiting time, if the time is specified, whether visible or not, it will be automatically loaded after the specified time
+     */
+    timeout: {
+        type: NumberConstructor;
+    };
+    /**
+     * The viewport where the component is located.
+     * If the component is scrolling in the page container, the viewport is the container
+     */
+    viewport: {
+        type: PropType<HTMLElement>;
+        default: () => any;
+    };
+    /**
+     * Preload threshold, css unit
+     */
+    threshold: {
+        type: StringConstructor;
+        default: string;
+    };
+    /**
+     * The scroll direction of the viewport, vertical represents the vertical direction, horizontal represents the horizontal direction
+     */
+    direction: {
+        type: StringConstructor;
+        default: string;
+        validator: (v: any) => boolean;
+    };
+    /**
+     * The label name of the outer container that wraps the component
+     */
+    tag: {
+        type: StringConstructor;
+        default: string;
+    };
+    maxWaitingTime: {
+        type: NumberConstructor;
+        default: number;
+    };
+    /**
+     * transition name
+     */
+    transitionName: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & {
+    onInit?: (...args: any[]) => any;
+}, {
+    threshold: string;
+    transitionName: string;
+    direction: string;
+    viewport: HTMLElement;
+    tag: string;
+    maxWaitingTime: number;
+}, {}>;
+export default _sfc_main;

package/es/ui/src/Container/src/ScrollContainer.vue.d.ts

@@ -0,0 +1,9 @@
+declare const _sfc_main: import("vue").DefineComponent<{}, {
+    scrollbarRef: import("vue").Ref<{
+        wrap: HTMLDivElement;
+    }>;
+    scrollTo: (to: number, duration?: number) => void;
+    scrollBottom: () => void;
+    getScrollWrap: () => HTMLDivElement;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}, {}>;
+export default _sfc_main;