cnhis-design-vue 3.1.37-beta.2 → 3.1.37

package/es/shared/components/VueDraggable/src/core/componentBuilderHelper.d.ts

@@ -0,0 +1,9 @@
+export function getComponentAttributes({ $attrs, componentData }: {
+    $attrs: any;
+    componentData?: {} | undefined;
+}): any;
+export function createSortableOption({ $attrs, callBackBuilder }: {
+    $attrs: any;
+    callBackBuilder: any;
+}): any;
+export function getValidSortableEntries(value: any): any[][];

package/es/shared/components/VueDraggable/src/core/componentStructure.d.ts

@@ -0,0 +1,22 @@
+export class ComponentStructure {
+    constructor({ nodes: { header, default: defaultNodes, footer }, root, realList }: {
+        nodes: {
+            header: any;
+            default: any;
+            footer: any;
+        };
+        root: any;
+        realList: any;
+    });
+    defaultNodes: any;
+    children: any[];
+    externalComponent: any;
+    rootTransition: any;
+    tag: any;
+    realList: any;
+    get _isRootComponent(): any;
+    render(h: any, attributes: any): any;
+    updated(): void;
+    getUnderlyingVm(domElement: any): any;
+    getVmIndexFromDomIndex(domIndex: any, element: any): any;
+}

package/es/shared/components/VueDraggable/src/core/renderHelper.d.ts

@@ -0,0 +1,7 @@
+export function computeComponentStructure({ $slots, tag, realList, getKey }: {
+    $slots: any;
+    tag: any;
+    realList: any;
+    getKey: any;
+}): ComponentStructure;
+import { ComponentStructure } from "./componentStructure";

package/es/shared/components/VueDraggable/src/core/sortableEvents.d.ts

@@ -0,0 +1,10 @@
+export namespace events {
+    export { manage };
+    export { manageAndEmit };
+    export { emit };
+}
+export function isReadOnly(eventName: any): boolean;
+declare const manage: string[];
+declare const manageAndEmit: string[];
+declare const emit: string[];
+export {};

package/es/shared/components/VueDraggable/src/util/console.d.ts

@@ -0,0 +1 @@
+export const console: Console;

package/es/shared/components/VueDraggable/src/util/htmlHelper.d.ts

@@ -0,0 +1,2 @@
+export function insertNodeAt(fatherNode: any, node: any, position: any): void;
+export function removeNode(node: any): void;

package/es/shared/components/VueDraggable/src/util/string.d.ts

@@ -0,0 +1 @@
+export function camelize(str: any): any;

package/es/shared/components/VueDraggable/src/util/tags.d.ts

@@ -0,0 +1,3 @@
+export function isHtmlTag(name: any): boolean;
+export function isHtmlAttribute(value: any): any;
+export function isTransition(name: any): boolean;

package/es/shared/components/VueDraggable/src/vuedraggable.d.ts

@@ -0,0 +1,86 @@
+declare const draggableComponent: import('vue').DefineComponent<
+	{
+		list: {
+			type: ArrayConstructor;
+			required: boolean;
+			default: any;
+		};
+		modelValue: {
+			type: ArrayConstructor;
+			required: boolean;
+			default: any;
+		};
+		itemKey: {
+			type: (FunctionConstructor | StringConstructor)[];
+			required: boolean;
+		};
+		clone: {
+			type: FunctionConstructor;
+			default: (original: any) => any;
+		};
+		tag: {
+			type: StringConstructor;
+			default: string;
+		};
+		move: {
+			type: FunctionConstructor;
+			default: any;
+		};
+		componentData: {
+			type: ObjectConstructor;
+			required: boolean;
+			default: any;
+		};
+	},
+	unknown,
+	{
+		error: boolean;
+	},
+	{
+		realList(): any;
+		getKey(): any;
+	},
+	{
+		getUnderlyingVm(domElement: any): any;
+		getUnderlyingPotencialDraggableComponent(htmElement: any): any;
+		emitChanges(evt: any): void;
+		alterList(onList: any): void;
+		spliceList(): void;
+		updatePosition(oldIndex: any, newIndex: any): void;
+		getRelatedContextFromMoveEvent({ to, related }: { to: any; related: any }): any;
+		getVmIndexFromDomIndex(domIndex: any): any;
+		onDragStart(evt: any): void;
+		onDragAdd(evt: any): void;
+		onDragRemove(evt: any): void;
+		onDragUpdate(evt: any): void;
+		computeFutureIndex(relatedContext: any, evt: any): any;
+		onDragMove(evt: any, originalEvent: any): any;
+		onDragEnd(): void;
+	},
+	import('vue').ComponentOptionsMixin,
+	import('vue').ComponentOptionsMixin,
+	any[],
+	any,
+	import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps,
+	Readonly<
+		{
+			move: Function;
+			tag: string;
+			clone: Function;
+			list: unknown[];
+			modelValue: unknown[];
+			componentData: Record<string, any>;
+		} & {
+			itemKey?: string | Function;
+		}
+	>,
+	{
+		move: Function;
+		tag: string;
+		clone: Function;
+		list: unknown[];
+		modelValue: unknown[];
+		componentData: Record<string, any>;
+	}
+>;
+export default draggableComponent;

package/es/shared/components/no-data/NoData.vue.d.ts

@@ -0,0 +1,49 @@
+declare const _default: import("vue").DefineComponent<{
+    noDataTip: {
+        type: StringConstructor;
+        default: string;
+    };
+    noDataImg: {
+        type: StringConstructor;
+        default: string;
+    };
+    showImg: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    imgStr: import("vue").ComputedRef<null>;
+    props: Readonly<import("@vue/shared").LooseRequired<Readonly<import("vue").ExtractPropTypes<{
+        noDataTip: {
+            type: StringConstructor;
+            default: string;
+        };
+        noDataImg: {
+            type: StringConstructor;
+            default: string;
+        };
+        showImg: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & {}>>;
+    handleDesc: import("vue").ComputedRef<string>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    noDataTip: {
+        type: StringConstructor;
+        default: string;
+    };
+    noDataImg: {
+        type: StringConstructor;
+        default: string;
+    };
+    showImg: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    noDataTip: string;
+    noDataImg: string;
+    showImg: boolean;
+}>;
+export default _default;

package/es/shared/components/no-data/index.d.ts

@@ -0,0 +1,2 @@
+import script from './NoData.vue';
+export default script;

package/es/shared/components/player-vod/index.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{}>>, {}>;
+export default _default;

package/es/shared/components/player-vod/player.d.ts

@@ -0,0 +1,17 @@
+import 'video.js/dist/video-js.css';
+declare const _default: import("vue").DefineComponent<{
+    options: {
+        type: ObjectConstructor;
+        required: true;
+        default: () => void;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    options: {
+        type: ObjectConstructor;
+        required: true;
+        default: () => void;
+    };
+}>>, {
+    options: Record<string, any>;
+}>;
+export default _default;

package/es/shared/components/player-vod/video-list.d.ts

@@ -0,0 +1,32 @@
+declare const _default: import("vue").DefineComponent<{
+    propsList: {
+        type: (ArrayConstructor | StringConstructor)[];
+        default: () => never[];
+    };
+    columnName: {
+        type: StringConstructor;
+        default: string;
+    };
+    stlist: {
+        type: StringConstructor;
+        default: string;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    propsList: {
+        type: (ArrayConstructor | StringConstructor)[];
+        default: () => never[];
+    };
+    columnName: {
+        type: StringConstructor;
+        default: string;
+    };
+    stlist: {
+        type: StringConstructor;
+        default: string;
+    };
+}>>, {
+    columnName: string;
+    propsList: string | unknown[];
+    stlist: string;
+}>;
+export default _default;

package/es/shared/components/player-vod/video-modal.d.ts

@@ -0,0 +1,54 @@
+declare const _default: import("vue").DefineComponent<{
+    visible: BooleanConstructor;
+    formData: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    playerOptions: {
+        type: ObjectConstructor;
+        default: () => {
+            sources: {
+                type: string;
+                src: string;
+            }[];
+        };
+    };
+    fileList: {
+        type: ArrayConstructor;
+        default: () => never[];
+    };
+    palyerIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+}, () => JSX.Element, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    visible: BooleanConstructor;
+    formData: {
+        type: ObjectConstructor;
+        default: () => {};
+    };
+    playerOptions: {
+        type: ObjectConstructor;
+        default: () => {
+            sources: {
+                type: string;
+                src: string;
+            }[];
+        };
+    };
+    fileList: {
+        type: ArrayConstructor;
+        default: () => never[];
+    };
+    palyerIndex: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>>, {
+    visible: boolean;
+    formData: Record<string, any>;
+    fileList: unknown[];
+    playerOptions: Record<string, any>;
+    palyerIndex: number;
+}>;
+export default _default;

package/es/shared/global/variable.d.ts

@@ -0,0 +1 @@
+export declare const COMPONENT_NAMESPACE = "C";

package/es/shared/types/index.d.ts

@@ -0,0 +1,22 @@
+import { App } from '@vue/runtime-core';
+export declare type SFCWithInstall<T> = T & {
+    install: (app: App, ...options: any[]) => any;
+};
+export declare type AnyObject = Record<string, any>;
+export declare type Func<T extends Array<any> = any[], P = any> = (...args: T) => P;
+export declare type Nullable<T> = T | null | undefined;
+export declare type UndefinedAble<T> = T | undefined;
+export declare type ArrayAble<T> = T | T[];
+export declare type Copy<T> = {
+    [K in keyof T]: T[K];
+};
+export declare type PropertyRequired<T, K extends keyof T> = Copy<{
+    [KEY in keyof T as KEY extends K ? never : KEY]: T[KEY];
+} & {
+    [KEY in K]-?: T[KEY];
+}>;
+export declare type TupleToUnion<T extends readonly unknown[]> = T[number];
+declare type UnionToIntersection<T> = (T extends T ? (params: T) => any : never) extends (P: infer R) => any ? R : never;
+export declare type UnionToTuple<T, Result extends unknown[] = []> = UnionToIntersection<T extends any ? () => T : never> extends () => infer Return ? UnionToTuple<Exclude<T, Return>, [Return, ...Result]> : Result;
+export declare type MaybeString<T extends string | number> = T | `${T}`;
+export {};

package/es/shared/utils/anime.d.ts

@@ -0,0 +1,35 @@
+declare function bounceOut(x: number): number;
+declare const animeType: {
+    easeInQuad: (x: number) => number;
+    easeOutQuad: (x: number) => number;
+    easeInOutQuad: (x: number) => number;
+    easeInCubic: (x: number) => number;
+    easeOutCubic: (x: number) => number;
+    easeInOutCubic: (x: number) => number;
+    easeInQuart: (x: number) => number;
+    easeOutQuart: (x: number) => number;
+    easeInOutQuart: (x: number) => number;
+    easeInQuint: (x: number) => number;
+    easeOutQuint: (x: number) => number;
+    easeInOutQuint: (x: number) => number;
+    easeInSine: (x: number) => number;
+    easeOutSine: (x: number) => number;
+    easeInOutSine: (x: number) => number;
+    easeInExpo: (x: number) => number;
+    easeOutExpo: (x: number) => number;
+    easeInOutExpo: (x: number) => number;
+    easeInCirc: (x: number) => number;
+    easeOutCirc: (x: number) => number;
+    easeInOutCirc: (x: number) => number;
+    easeInElastic: (x: number) => number;
+    easeOutElastic: (x: number) => number;
+    easeInOutElastic: (x: number) => number;
+    easeInBack: (x: number) => number;
+    easeOutBack: (x: number) => number;
+    easeInOutBack: (x: number) => number;
+    easeInBounce: (x: number) => number;
+    easeOutBounce: typeof bounceOut;
+    easeInOutBounce: (x: number) => number;
+};
+export declare const doAnimation: (startValue: number, endValue: number, during: number | undefined, callback: (v: number) => void, type?: keyof typeof animeType, onAnimationEnd?: ((...args: unknown[]) => void) | undefined) => void;
+export {};

package/es/shared/utils/colorLog.d.ts

@@ -0,0 +1,31 @@
+export declare enum LogsType {
+    DEFAULT = "default",
+    PRIMARY = "primary",
+    SUCCESS = "success",
+    WARNING = "warning",
+    DANGER = "danger"
+}
+declare class Log {
+    /**
+     * @description 打印一个 [ title | text ] 样式的信息
+     * @param {String} title title text
+     * @param {String} info info text
+     * @param {String} type style
+     * @param {any[]} appendInfo
+     */
+    capsule(title: string, info: any, type?: LogsType, ...appendInfo: any[]): void;
+    /**
+     * @description 打印彩色文字
+     */
+    colorful(textArr: {
+        text: any;
+        type: LogsType;
+    }[]): void;
+    text(text: any): void;
+    primary(text: any): void;
+    success(text: any): void;
+    warning(text: any): void;
+    danger(text: any): void;
+}
+declare const log: Log;
+export default log;

package/es/shared/utils/index.d.ts

@@ -0,0 +1,16 @@
+import { AnyObject, ArrayAble } from '../../../es/shared/types';
+import { App, Component } from 'vue';
+export declare function traverse<T extends ArrayAble<AnyObject>>(target: T, handler: (item: T extends Array<infer P> ? P : T, stop: () => void, parent?: typeof item) => void, keys?: ArrayAble<string>, parent?: T): void;
+export declare function safeComponentRegister(app: App, component: Component, cName?: string | undefined, scheduler?: () => void): void;
+export declare function generateTimeFormat(format: string): string | undefined;
+export declare function arrayed<T>(maybeArray: T): T extends Array<any> ? T : [T];
+export declare function uuidGenerator(): string;
+export declare const getStringWidth: import("@vueuse/core").UseMemoizedFn<number, [str: string]>;
+export declare const DMZ: AnyObject;
+export declare function deepOmit<T extends AnyObject>(target: T, keys: Array<keyof T>): any;
+export declare function separateMetaModule<T extends AnyObject>(modules: Record<string, unknown>): T;
+export declare function findAncestor(ele: HTMLElement | null, finder: (ele: HTMLElement) => boolean): HTMLElement | null;
+export declare function widthAppend(value: string | number, append?: string): string;
+export declare function targetStringIncludes(arr: string[], target: string): boolean;
+export declare const jsonParse: import("@vueuse/core").UseMemoizedFn<any, [value: string]>;
+export declare function shallowOmit<T, K extends Array<keyof T>>(target: T, keys: K): Omit<T, K[number]>;

package/es/shared/utils/loadViewer.d.ts

@@ -0,0 +1,2 @@
+import { App } from 'vue';
+export declare function loadViewer(app: App): void;

package/es/shared/utils/tapable/AsyncParallelBailHook.d.ts

@@ -0,0 +1,3 @@
+export default AsyncParallelBailHook;
+declare function AsyncParallelBailHook(args?: any[], name?: undefined): Hook;
+import Hook from "./Hook";

package/es/shared/utils/tapable/AsyncParallelHook.d.ts

@@ -0,0 +1,3 @@
+export default AsyncParallelHook;
+declare function AsyncParallelHook(args?: any[], name?: undefined): Hook;
+import Hook from "./Hook";

package/es/shared/utils/tapable/AsyncSeriesBailHook.d.ts

@@ -0,0 +1,3 @@
+export default AsyncSeriesBailHook;
+declare function AsyncSeriesBailHook(args?: any[], name?: undefined): Hook;
+import Hook from "./Hook";

package/es/shared/utils/tapable/AsyncSeriesHook.d.ts

@@ -0,0 +1,3 @@
+export default AsyncSeriesHook;
+declare function AsyncSeriesHook(args?: any[], name?: undefined): Hook;
+import Hook from "./Hook";

package/es/shared/utils/tapable/AsyncSeriesLoopHook.d.ts

@@ -0,0 +1,3 @@
+export default AsyncSeriesLoopHook;
+declare function AsyncSeriesLoopHook(args?: any[], name?: undefined): Hook;
+import Hook from "./Hook";

package/es/shared/utils/tapable/AsyncSeriesWaterfallHook.d.ts

@@ -0,0 +1,3 @@
+export default AsyncSeriesWaterfallHook;
+declare function AsyncSeriesWaterfallHook(args?: any[], name?: undefined): Hook;
+import Hook from "./Hook";

package/es/shared/utils/tapable/Hook.d.ts

@@ -0,0 +1,50 @@
+export default Hook;
+declare class Hook {
+    constructor(args?: any[], name?: undefined);
+    _args: any[];
+    name: any;
+    taps: any[];
+    interceptors: any[];
+    _call: typeof CALL_DELEGATE;
+    call: typeof CALL_DELEGATE;
+    _callAsync: typeof CALL_ASYNC_DELEGATE;
+    callAsync: typeof CALL_ASYNC_DELEGATE;
+    _promise: typeof PROMISE_DELEGATE;
+    promise: typeof PROMISE_DELEGATE;
+    _x: any;
+    compile(): void;
+    _createCall(type: any): void;
+    _tap(type: any, options: any, fn: any): void;
+    tap(options: any, fn: any): void;
+    tapAsync(options: any, fn: any): void;
+    tapPromise(options: any, fn: any): void;
+    _runRegisterInterceptors(options: any): any;
+    withOptions(options: any): {
+        name: any;
+        tap: (opt: any, fn: any) => void;
+        tapAsync: (opt: any, fn: any) => void;
+        tapPromise: (opt: any, fn: any) => void;
+        intercept: (interceptor: any) => void;
+        isUsed: () => boolean;
+        withOptions: (opt: any) => any;
+    };
+    isUsed(): boolean;
+    intercept(interceptor: any): void;
+    _resetCompilation(): void;
+    _insert(item: any): void;
+}
+declare function CALL_DELEGATE(...args: any[]): any;
+declare class CALL_DELEGATE {
+    constructor(...args: any[]);
+    call: any;
+}
+declare function CALL_ASYNC_DELEGATE(...args: any[]): any;
+declare class CALL_ASYNC_DELEGATE {
+    constructor(...args: any[]);
+    callAsync: any;
+}
+declare function PROMISE_DELEGATE(...args: any[]): any;
+declare class PROMISE_DELEGATE {
+    constructor(...args: any[]);
+    promise: any;
+}

package/es/shared/utils/tapable/HookCodeFactory.d.ts

@@ -0,0 +1,58 @@
+export default HookCodeFactory;
+declare class HookCodeFactory {
+    constructor(config: any);
+    config: any;
+    options: {
+        type: "sync" | "promise" | "async";
+        taps: Array<Tap>;
+        interceptors: Array<Interceptor>;
+    } | undefined;
+    _args: any;
+    create(options: any): Function;
+    setup(instance: any, options: any): void;
+    /**
+     * @param {{ type: "sync" | "promise" | "async", taps: Array<Tap>, interceptors: Array<Interceptor> }} options
+     */
+    init(options: {
+        type: "sync" | "promise" | "async";
+        taps: Array<Tap>;
+        interceptors: Array<Interceptor>;
+    }): void;
+    deinit(): void;
+    contentWithInterceptors(options: any): any;
+    header(): string;
+    needContext(): boolean;
+    callTap(tapIndex: any, { onError, onResult, onDone, rethrowIfPossible }: {
+        onError: any;
+        onResult: any;
+        onDone: any;
+        rethrowIfPossible: any;
+    }): string;
+    callTapsSeries({ onError, onResult, resultReturns, onDone, doneReturns, rethrowIfPossible }: {
+        onError: any;
+        onResult: any;
+        resultReturns: any;
+        onDone: any;
+        doneReturns: any;
+        rethrowIfPossible: any;
+    }): any;
+    callTapsLooping({ onError, onDone, rethrowIfPossible }: {
+        onError: any;
+        onDone: any;
+        rethrowIfPossible: any;
+    }): any;
+    callTapsParallel({ onError, onResult, onDone, rethrowIfPossible, onTap }: {
+        onError: any;
+        onResult: any;
+        onDone: any;
+        rethrowIfPossible: any;
+        onTap?: ((i: any, run: any) => any) | undefined;
+    }): any;
+    args({ before, after }?: {
+        before: any;
+        after: any;
+    }): any;
+    getTapFn(idx: any): string;
+    getTap(idx: any): string;
+    getInterceptor(idx: any): string;
+}

package/es/shared/utils/tapable/HookMap.d.ts

@@ -0,0 +1,11 @@
+export default HookMap;
+declare class HookMap {
+    constructor(factory: any, name?: undefined);
+    _map: Map<any, any>;
+    name: any;
+    _factory: any;
+    _interceptors: any[];
+    get(key: any): any;
+    for(key: any): any;
+    intercept(interceptor: any): void;
+}

package/es/shared/utils/tapable/MultiHook.d.ts

@@ -0,0 +1,12 @@
+export default MultiHook;
+declare class MultiHook {
+    constructor(hooks: any, name?: undefined);
+    hooks: any;
+    name: any;
+    tap(options: any, fn: any): void;
+    tapAsync(options: any, fn: any): void;
+    tapPromise(options: any, fn: any): void;
+    isUsed(): boolean;
+    intercept(interceptor: any): void;
+    withOptions(options: any): MultiHook;
+}

package/es/shared/utils/tapable/SyncBailHook.d.ts

@@ -0,0 +1,3 @@
+export default SyncBailHook;
+declare function SyncBailHook(args?: any[], name?: undefined): Hook;
+import Hook from "./Hook";

package/es/shared/utils/tapable/SyncHook.d.ts

@@ -0,0 +1,3 @@
+export default SyncHook;
+declare function SyncHook(args?: any[], name?: undefined): Hook;
+import Hook from "./Hook";

package/es/shared/utils/tapable/SyncLoopHook.d.ts

@@ -0,0 +1,3 @@
+export default SyncLoopHook;
+declare function SyncLoopHook(args?: any[], name?: undefined): Hook;
+import Hook from "./Hook";

package/es/shared/utils/tapable/SyncWaterfallHook.d.ts

@@ -0,0 +1,3 @@
+export default SyncWaterfallHook;
+declare function SyncWaterfallHook(args?: any[], name?: undefined): Hook;
+import Hook from "./Hook";