@privyid/persona 1.2.1 → 1.2.2-rc.2

package/dist/components/table/Table.vue.d.ts

@@ -0,0 +1,337 @@
+import type { PropType } from 'vue';
+import type { TableField } from '.';
+type TypeVariant = 'flexible' | 'static';
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    variant: {
+        type: PropType<TypeVariant>;
+        default: string;
+    };
+    modelValue: {
+        type: PropType<Record<string, any>[]>;
+        default: () => never[];
+    };
+    fields: {
+        type: PropType<TableField<Record<string, any>>[]>;
+        default: () => never[];
+    };
+    items: {
+        type: PropType<Record<string, any>[]>;
+        default: () => never[];
+    };
+    selectable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    emptyLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    noLabel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showTableHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, {
+    model: import("vue").Ref<Record<string, any>[], Record<string, any>[]>;
+    rows: import("vue").WritableComputedRef<Record<string, unknown>[], Record<string, unknown>[]>;
+    classNames: import("vue").ComputedRef<string[]>;
+    selectAll: import("vue").WritableComputedRef<boolean, boolean>;
+    indeterminate: import("vue").ComputedRef<boolean>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "update:items")[], "update:modelValue" | "update:items", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    variant: {
+        type: PropType<TypeVariant>;
+        default: string;
+    };
+    modelValue: {
+        type: PropType<Record<string, any>[]>;
+        default: () => never[];
+    };
+    fields: {
+        type: PropType<TableField<Record<string, any>>[]>;
+        default: () => never[];
+    };
+    items: {
+        type: PropType<Record<string, any>[]>;
+        default: () => never[];
+    };
+    selectable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    emptyLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    noLabel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showTableHeader: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:items"?: ((...args: any[]) => any) | undefined;
+}>, {
+    modelValue: Record<string, any>[];
+    items: Record<string, any>[];
+    variant: TypeVariant;
+    draggable: boolean;
+    selectable: boolean;
+    fields: TableField<Record<string, any>>[];
+    emptyLabel: string;
+    noLabel: boolean;
+    showTableHeader: boolean;
+}, {}, {
+    Checkbox: {
+        new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+            name: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            modelValue: {
+                type: PropType<any>;
+                default: boolean;
+            };
+            value: {
+                type: PropType<any>;
+                default: boolean;
+            };
+            uncheckedValue: {
+                type: PropType<any>;
+                default: boolean;
+            };
+            checked: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            readonly: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            indeterminate: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            "onUpdate:modelValue"?: ((args_0: unknown) => any) | undefined;
+            onChange?: ((args_0: boolean) => any) | undefined;
+        }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+            "update:modelValue": (args_0: unknown) => void;
+            change: (args_0: boolean) => void;
+        }, import("vue").PublicProps, {
+            value: any;
+            name: string;
+            modelValue: any;
+            disabled: boolean;
+            readonly: boolean;
+            checked: boolean;
+            uncheckedValue: any;
+            indeterminate: boolean;
+        }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import("vue").ExtractPropTypes<{
+            name: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            modelValue: {
+                type: PropType<any>;
+                default: boolean;
+            };
+            value: {
+                type: PropType<any>;
+                default: boolean;
+            };
+            uncheckedValue: {
+                type: PropType<any>;
+                default: boolean;
+            };
+            checked: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            readonly: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            indeterminate: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & Readonly<{
+            "onUpdate:modelValue"?: ((args_0: unknown) => any) | undefined;
+            onChange?: ((args_0: boolean) => any) | undefined;
+        }>, {}, {}, {}, {}, {
+            value: any;
+            name: string;
+            modelValue: any;
+            disabled: boolean;
+            readonly: boolean;
+            checked: boolean;
+            uncheckedValue: any;
+            indeterminate: boolean;
+        }>;
+        __isFragment?: never;
+        __isTeleport?: never;
+        __isSuspense?: never;
+    } & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+        name: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        modelValue: {
+            type: PropType<any>;
+            default: boolean;
+        };
+        value: {
+            type: PropType<any>;
+            default: boolean;
+        };
+        uncheckedValue: {
+            type: PropType<any>;
+            default: boolean;
+        };
+        checked: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        readonly: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        indeterminate: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{
+        "onUpdate:modelValue"?: ((args_0: unknown) => any) | undefined;
+        onChange?: ((args_0: boolean) => any) | undefined;
+    }>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+        "update:modelValue": (args_0: unknown) => void;
+        change: (args_0: boolean) => void;
+    }, string, {
+        value: any;
+        name: string;
+        modelValue: any;
+        disabled: boolean;
+        readonly: boolean;
+        checked: boolean;
+        uncheckedValue: any;
+        indeterminate: boolean;
+    }, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+        $slots: Readonly<{
+            default(props: {
+                isChecked: boolean;
+            }): import("vue").VNode[];
+        }> & {
+            default(props: {
+                isChecked: boolean;
+            }): import("vue").VNode[];
+        };
+    });
+    IconDrag: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    Draggable: 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>;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/components/table/index.d.ts

@@ -0,0 +1,49 @@
+import type { HTMLAttributes } from 'vue';
+import type { LiteralUnion } from 'type-fest';
+export type KeyType<T> = LiteralUnion<keyof T & string, string>;
+export type LabelType<T> = LiteralUnion<Capitalize<keyof T & string>, string>;
+export type ApperanceVariant = 'card' | 'table';
+export interface TableField<T = Record<string, unknown>> {
+    /**
+     * Field's key
+     */
+    key: KeyType<T>;
+    /**
+     * Field's Label
+     */
+    label?: LabelType<T>;
+    /**
+     * field width, value in percent
+     */
+    width?: number | string;
+    /**
+     * Function for transforming value in
+     */
+    formatter?: (value: unknown, item: T) => string;
+    /**
+     * Additional class to td element
+     */
+    tdClass?: HTMLAttributes['class'];
+    /**
+     * Additional class to th element
+     */
+    thClass?: HTMLAttributes['class'];
+    /**
+     * Enable sortable field
+     * @default true
+     */
+    sortable?: boolean;
+}
+export declare function baseFormatter(value: unknown): string;
+export declare function defineTable<T = unknown>(fields: Array<TableField<T>> | string[]): Array<TableField<T>>;
+export declare function withKey(item: object): Omit<object, never> & Omit<{
+    _key: symbol;
+}, never> & {};
+export declare function withoutKey(item: Record<string, unknown>): Pick<Record<string, unknown>, string>;
+/**
+ * Add unit to unitless value
+ * @param value value
+ * @param unit default unit
+ */
+export declare function withUnit(value?: number | string | undefined, unit?: string): string | number | undefined;
+export declare function withoutUnit(value: string, unit?: string): number;

package/dist/components/table/index.mjs

@@ -0,0 +1,37 @@
+import defu from "defu";
+import {
+  startCase,
+  isNil,
+  omit
+} from "lodash-es";
+export function baseFormatter(value) {
+  return isNil(value) ? "-" : String(value);
+}
+function normalizeField(field) {
+  return defu(field, {
+    label: startCase(field.key),
+    formatter: baseFormatter
+  });
+}
+export function defineTable(fields) {
+  return fields.map((field) => {
+    return typeof field === "string" ? normalizeField({ key: field }) : normalizeField(field);
+  });
+}
+export function withKey(item) {
+  return defu(item, { _key: Symbol("item-key") });
+}
+export function withoutKey(item) {
+  return omit(item, "_key");
+}
+export function withUnit(value, unit = "%") {
+  if (!value)
+    return;
+  if (Number.isFinite(Number(value)))
+    return `${value}${unit}`;
+  return value;
+}
+export function withoutUnit(value, unit = "%") {
+  const val = value.endsWith(unit) ? value.slice(0, value.length - unit.length) : value;
+  return Number.parseFloat(val);
+}