prismify-ui 0.1.0-alpha.1

package/dist/components/data/PfTable/index.vue.d.ts

@@ -0,0 +1,166 @@
+import { Component, Ref, WatchOptions } from 'vue';
+import { Cell, Column, ColumnDef, ColumnFiltersState, ColumnOrderState, ColumnPinningState, ColumnSizingInfoState, ColumnSizingState, ExpandedState, FacetedOptions, GlobalFilterOptions, GroupingOptions, GroupingState, PaginationOptions, PaginationState, Row, RowData, RowPinningOptions, RowPinningState, RowSelectionOptions, RowSelectionState, SortingOptions, SortingState, TableMeta, TableOptions, VisibilityOptions, VisibilityState } from '@tanstack/table-core';
+export type PfTableColumn<TData extends import('@tanstack/table-core').RowData> = ColumnDef<TData, unknown>;
+export type PfTableRow<TData extends import('@tanstack/table-core').RowData> = Row<TData>;
+export type PfTableUi = Partial<{
+    root: string;
+    scroll: string;
+    base: string;
+    caption: string;
+    thead: string;
+    tbody: string;
+    tfoot: string;
+    tr: string;
+    th: string;
+    td: string;
+    separator: string;
+    empty: string;
+    loading: string;
+}>;
+export type PfTableLoadingColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'error' | 'neutral';
+export type PfTableLoadingAnimation = 'carousel' | 'carousel-inverse' | 'swing' | 'elastic';
+/** Optional `meta` on column defs — class, style, colspan, rowspan (PfTable). */
+export type PfTableColumnMeta<TData extends RowData = RowData> = {
+    class?: {
+        th?: string | ((arg: unknown) => string);
+        td?: string | ((arg: unknown) => string);
+    };
+    style?: {
+        th?: string | Record<string, string> | ((arg: unknown) => string | Record<string, string>);
+        td?: string | Record<string, string> | ((arg: unknown) => string | Record<string, string>);
+    };
+    colspan?: {
+        td?: string | ((cell: Cell<TData, unknown>) => string);
+    };
+    rowspan?: {
+        td?: string | ((cell: Cell<TData, unknown>) => string);
+    };
+};
+/** Optional `meta` on the table — row class/style (PfTable). */
+export type PfTableRowMeta = {
+    class?: {
+        tr?: string | ((arg: unknown) => string);
+    };
+    style?: {
+        tr?: string | Record<string, string> | ((arg: unknown) => string | Record<string, string>);
+    };
+};
+declare const _default: <TData extends import('@tanstack/table-core').RowData>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onSelect?: ((e: Event, row: Row<TData>) => any) | undefined;
+        readonly onContextmenu?: ((e: Event, row: Row<TData>) => any) | undefined;
+        readonly "onUpdate:globalFilter"?: ((value: string) => any) | undefined;
+        readonly "onUpdate:columnFilters"?: ((value: ColumnFiltersState) => any) | undefined;
+        readonly "onUpdate:columnOrder"?: ((value: ColumnOrderState) => any) | undefined;
+        readonly "onUpdate:columnVisibility"?: ((value: VisibilityState) => any) | undefined;
+        readonly "onUpdate:columnPinning"?: ((value: ColumnPinningState) => any) | undefined;
+        readonly "onUpdate:columnSizing"?: ((value: ColumnSizingState) => any) | undefined;
+        readonly "onUpdate:columnSizingInfo"?: ((value: ColumnSizingInfoState) => any) | undefined;
+        readonly "onUpdate:rowSelection"?: ((value: RowSelectionState) => any) | undefined;
+        readonly "onUpdate:rowPinning"?: ((value: RowPinningState) => any) | undefined;
+        readonly "onUpdate:sorting"?: ((value: SortingState) => any) | undefined;
+        readonly "onUpdate:grouping"?: ((value: GroupingState) => any) | undefined;
+        readonly "onUpdate:expanded"?: ((value: ExpandedState) => any) | undefined;
+        readonly "onUpdate:pagination"?: ((value: PaginationState) => any) | undefined;
+        readonly onHover?: ((e: Event, row: Row<TData> | null) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onSelect" | "onContextmenu" | "onUpdate:globalFilter" | "onUpdate:columnFilters" | "onUpdate:columnOrder" | "onUpdate:columnVisibility" | "onUpdate:columnPinning" | "onUpdate:columnSizing" | "onUpdate:columnSizingInfo" | "onUpdate:rowSelection" | "onUpdate:rowPinning" | "onUpdate:sorting" | "onUpdate:grouping" | "onUpdate:expanded" | "onUpdate:pagination" | "onHover"> & ({
+        globalFilter?: string;
+        columnFilters?: ColumnFiltersState;
+        columnOrder?: ColumnOrderState;
+        columnVisibility?: VisibilityState;
+        columnPinning?: ColumnPinningState;
+        columnSizing?: ColumnSizingState;
+        columnSizingInfo?: ColumnSizingInfoState;
+        rowSelection?: RowSelectionState;
+        rowPinning?: RowPinningState;
+        sorting?: SortingState;
+        grouping?: GroupingState;
+        expanded?: ExpandedState;
+        pagination?: PaginationState;
+    } & {
+        as?: string | Component;
+        data?: TData[];
+        columns?: ColumnDef<TData, unknown>[];
+        caption?: string;
+        meta?: TableMeta<TData>;
+        empty?: string;
+        sticky?: boolean | "header" | "footer";
+        loading?: boolean;
+        loadingColor?: PfTableLoadingColor;
+        loadingAnimation?: PfTableLoadingAnimation;
+        watchOptions?: WatchOptions;
+        globalFilterOptions?: Omit<GlobalFilterOptions<TData>, "onGlobalFilterChange">;
+        columnFiltersOptions?: Omit<NonNullable<TableOptions<TData>>, "getFilteredRowModel" | "onColumnFiltersChange">;
+        columnPinningOptions?: Omit<NonNullable<TableOptions<TData>>, "onColumnPinningChange">;
+        columnSizingOptions?: Omit<NonNullable<TableOptions<TData>>, "onColumnSizingChange" | "onColumnSizingInfoChange">;
+        visibilityOptions?: Omit<VisibilityOptions, "onColumnVisibilityChange">;
+        sortingOptions?: Omit<SortingOptions<TData>, "getSortedRowModel" | "onSortingChange">;
+        groupingOptions?: Omit<GroupingOptions, "onGroupingChange">;
+        expandedOptions?: Omit<NonNullable<TableOptions<TData>>, "getExpandedRowModel" | "onExpandedChange">;
+        rowSelectionOptions?: Omit<RowSelectionOptions<TData>, "onRowSelectionChange">;
+        rowPinningOptions?: Omit<RowPinningOptions<TData>, "onRowPinningChange">;
+        paginationOptions?: Omit<PaginationOptions, "onPaginationChange">;
+        facetedOptions?: FacetedOptions<TData>;
+        /** When set, row clicks invoke this handler (interactive controls inside the row are ignored). */
+        onSelect?: (e: Event, row: Row<TData>) => void;
+        /** When true, rows look clickable and emit `select` on click (unless the target is interactive). */
+        selectable?: boolean;
+        onHover?: (e: Event, row: Row<TData> | null) => void;
+        onContextmenu?: ((e: Event, row: Row<TData>) => void) | ((e: Event, row: Row<TData>) => void)[];
+        ui?: PfTableUi;
+        renderFallbackValue?: TableOptions<TData>["renderFallbackValue"];
+        virtualize?: boolean | Record<string, unknown>;
+        /** TanStack Table option (leading underscore). */
+        _features?: TableOptions<TData>["_features"];
+        autoResetAll?: TableOptions<TData>["autoResetAll"];
+        debugAll?: boolean;
+        debugCells?: boolean;
+        debugColumns?: boolean;
+        debugHeaders?: boolean;
+        debugRows?: boolean;
+        debugTable?: boolean;
+        defaultColumn?: Partial<ColumnDef<TData, unknown>>;
+        getRowId?: TableOptions<TData>["getRowId"];
+        getSubRows?: TableOptions<TData>["getSubRows"];
+        initialState?: TableOptions<TData>["initialState"];
+        mergeOptions?: TableOptions<TData>["mergeOptions"];
+    }) & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{
+        readonly $el: HTMLElement | null;
+        tableRef: Ref<HTMLTableElement | null, HTMLTableElement | null>;
+        tableApi: import('@tanstack/table-core').Table<TData>;
+    }>): void;
+    attrs: any;
+    slots: Partial<Record<string, (_: {
+        column: Column<TData, unknown>;
+        header: import('@tanstack/table-core').Header<TData, unknown>;
+        table: import('@tanstack/table-core').Table<TData>;
+    }) => any>> & Partial<Record<string, (_: {
+        cell: Cell<TData, unknown>;
+        column: Column<TData, unknown>;
+        getValue: import('@tanstack/table-core').Getter<unknown>;
+        renderValue: import('@tanstack/table-core').Getter<unknown>;
+        row: Row<TData>;
+        table: import('@tanstack/table-core').Table<TData>;
+    }) => any>> & Partial<Record<string, (_: {
+        column: Column<TData, unknown>;
+        header: import('@tanstack/table-core').Header<TData, unknown>;
+        table: import('@tanstack/table-core').Table<TData>;
+    }) => any>> & {
+        caption?(_: {}): any;
+        'body-top'?(_: {}): any;
+        loading?(_: {}): any;
+        empty?(_: {}): any;
+        expanded?(_: {
+            row: Row<TData>;
+        }): any;
+        'body-bottom'?(_: {}): any;
+    };
+    emit: (((evt: "select", e: Event, row: Row<TData>) => void) & ((evt: "contextmenu", e: Event, row: Row<TData>) => void) & ((evt: "hover", e: Event, row: Row<TData> | null) => void)) & (((evt: "update:globalFilter", value: string) => void) & ((evt: "update:columnFilters", value: ColumnFiltersState) => void) & ((evt: "update:columnOrder", value: ColumnOrderState) => void) & ((evt: "update:columnVisibility", value: VisibilityState) => void) & ((evt: "update:columnPinning", value: ColumnPinningState) => void) & ((evt: "update:columnSizing", value: ColumnSizingState) => void) & ((evt: "update:columnSizingInfo", value: ColumnSizingInfoState) => void) & ((evt: "update:rowSelection", value: RowSelectionState) => void) & ((evt: "update:rowPinning", value: RowPinningState) => void) & ((evt: "update:sorting", value: SortingState) => void) & ((evt: "update:grouping", value: GroupingState) => void) & ((evt: "update:expanded", value: ExpandedState) => void) & ((evt: "update:pagination", value: PaginationState) => void));
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/components/data/PfTimeline/index.vue.d.ts

@@ -0,0 +1,105 @@
+import { Component } from 'vue';
+import { PfBadgeAvatarProps } from '../../element/PfBadge/index.vue';
+import { PfIconName } from '../../element/PfIcon/paths';
+export type PfTimelineColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'error' | 'neutral';
+export type PfTimelineSize = '2xs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl';
+export type PfTimelineOrientation = 'horizontal' | 'vertical';
+export type PfTimelineItemUi = Partial<{
+    item: string;
+    container: string;
+    indicator: string;
+    separator: string;
+    wrapper: string;
+    date: string;
+    title: string;
+    description: string;
+}>;
+export interface PfTimelineItem {
+    date?: string;
+    title?: string;
+    description?: string;
+    icon?: PfIconName;
+    avatar?: PfBadgeAvatarProps;
+    value?: string | number;
+    slot?: string;
+    class?: unknown;
+    ui?: PfTimelineItemUi;
+}
+export type PfTimelineUi = Partial<{
+    root: string;
+    item: string;
+    container: string;
+    indicator: string;
+    separator: string;
+    wrapper: string;
+    date: string;
+    title: string;
+    description: string;
+}>;
+type __VLS_Props = {
+    as?: string | Component;
+    items?: readonly PfTimelineItem[];
+    size?: PfTimelineSize;
+    color?: PfTimelineColor;
+    orientation?: PfTimelineOrientation;
+    valueKey?: string;
+    defaultValue?: string | number;
+    modelValue?: string | number;
+    ui?: PfTimelineUi;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Partial<Record<`${string}-indicator`, (_: {
+        item: PfTimelineItem;
+        index: number;
+    }) => any>> & Partial<Record<`${string}-date`, (_: {
+        item: PfTimelineItem;
+        index: number;
+    }) => any>> & Partial<Record<`${string}-title`, (_: {
+        item: PfTimelineItem;
+        index: number;
+    }) => any>> & Partial<Record<`${string}-description`, (_: {
+        item: PfTimelineItem;
+        index: number;
+    }) => any>> & {
+        indicator?(_: {
+            item: PfTimelineItem;
+            index: number;
+        }): any;
+        date?(_: {
+            item: PfTimelineItem;
+            index: number;
+        }): any;
+        title?(_: {
+            item: PfTimelineItem;
+            index: number;
+        }): any;
+        description?(_: {
+            item: PfTimelineItem;
+            index: number;
+        }): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (event: Event, item: PfTimelineItem) => any;
+    "update:modelValue": (value: string | number | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((event: Event, item: PfTimelineItem) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string | number | undefined) => any) | undefined;
+}>, {
+    size: PfTimelineSize;
+    color: PfTimelineColor;
+    orientation: PfTimelineOrientation;
+    valueKey: string;
+    items: readonly PfTimelineItem[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/data/PfTree/PfTreeBranch.vue.d.ts

@@ -0,0 +1,78 @@
+import { Component, PropType } from 'vue';
+import { PfTreeItem } from './treeTypes';
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<{
+        'item-leading'(props: {
+            item: PfTreeItem;
+            itemKey: string;
+            selected: boolean;
+            indeterminate: boolean;
+            handleSelect: () => void;
+        }): unknown;
+        'item-label'(props: {
+            item: PfTreeItem;
+            itemKey: string;
+            selected: boolean;
+        }): unknown;
+        'item-trailing'(props: {
+            item: PfTreeItem;
+            itemKey: string;
+            selected: boolean;
+        }): unknown;
+    }> & {
+        'item-leading'(props: {
+            item: PfTreeItem;
+            itemKey: string;
+            selected: boolean;
+            indeterminate: boolean;
+            handleSelect: () => void;
+        }): unknown;
+        'item-label'(props: {
+            item: PfTreeItem;
+            itemKey: string;
+            selected: boolean;
+        }): unknown;
+        'item-trailing'(props: {
+            item: PfTreeItem;
+            itemKey: string;
+            selected: boolean;
+        }): unknown;
+    };
+    refs: {};
+    rootEl: HTMLUListElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    items: {
+        type: PropType<readonly PfTreeItem[]>;
+        required: true;
+    };
+    pathPrefix: {
+        type: StringConstructor;
+        default: string;
+    };
+    flat: BooleanConstructor;
+    linkAs: PropType<string | Component | undefined>;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    items: {
+        type: PropType<readonly PfTreeItem[]>;
+        required: true;
+    };
+    pathPrefix: {
+        type: StringConstructor;
+        default: string;
+    };
+    flat: BooleanConstructor;
+    linkAs: PropType<string | Component | undefined>;
+}>> & Readonly<{}>, {
+    flat: boolean;
+    pathPrefix: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, HTMLUListElement>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/data/PfTree/PfTreeRow.vue.d.ts

@@ -0,0 +1,107 @@
+import { Component, PropType } from 'vue';
+import { PfIconName } from '../../element/PfIcon/paths';
+import { PfTreeItem, PfTreeItemUi } from './treeTypes';
+declare function handleSelectFromSlot(): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        'item-leading'?(_: {
+            item: PfTreeItem;
+            itemKey: string;
+            selected: boolean;
+            indeterminate: boolean;
+            handleSelect: typeof handleSelectFromSlot;
+        }): any;
+        'item-label'?(_: {
+            item: PfTreeItem;
+            itemKey: string;
+            selected: boolean;
+        }): any;
+        'item-trailing'?(_: {
+            item: PfTreeItem;
+            itemKey: string;
+            selected: boolean;
+        }): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    itemKey: {
+        type: StringConstructor;
+        required: true;
+    };
+    item: {
+        type: PropType<PfTreeItem>;
+        required: true;
+    };
+    depth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    flat: BooleanConstructor;
+    hasChildren: BooleanConstructor;
+    expanded: BooleanConstructor;
+    selected: BooleanConstructor;
+    indeterminate: BooleanConstructor;
+    disabled: BooleanConstructor;
+    linkAs: PropType<string | Component | undefined>;
+    trailingChevron: {
+        type: PropType<PfIconName>;
+        required: true;
+    };
+    leadingIcon: PropType<PfIconName | undefined>;
+    leadingImageSrc: PropType<string | undefined>;
+    leadingImageAlt: PropType<string | undefined>;
+    ui: PropType<PfTreeItemUi | undefined>;
+}>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (e: MouseEvent) => any;
+    toggle: (e: MouseEvent) => any;
+}, string, import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    itemKey: {
+        type: StringConstructor;
+        required: true;
+    };
+    item: {
+        type: PropType<PfTreeItem>;
+        required: true;
+    };
+    depth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    flat: BooleanConstructor;
+    hasChildren: BooleanConstructor;
+    expanded: BooleanConstructor;
+    selected: BooleanConstructor;
+    indeterminate: BooleanConstructor;
+    disabled: BooleanConstructor;
+    linkAs: PropType<string | Component | undefined>;
+    trailingChevron: {
+        type: PropType<PfIconName>;
+        required: true;
+    };
+    leadingIcon: PropType<PfIconName | undefined>;
+    leadingImageSrc: PropType<string | undefined>;
+    leadingImageAlt: PropType<string | undefined>;
+    ui: PropType<PfTreeItemUi | undefined>;
+}>> & Readonly<{
+    onSelect?: ((e: MouseEvent) => any) | undefined;
+    onToggle?: ((e: MouseEvent) => any) | undefined;
+}>, {
+    flat: boolean;
+    disabled: boolean;
+    indeterminate: boolean;
+    selected: boolean;
+    expanded: boolean;
+    depth: number;
+    hasChildren: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};