prismify-ui 0.1.0-alpha.1

package/dist/components/form/PfRadio/index.vue.d.ts

@@ -0,0 +1,76 @@
+import { Component } from 'vue';
+export type PfRadioColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'error' | 'neutral';
+export type PfRadioVariant = 'card' | 'list';
+export type PfRadioSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type PfRadioIndicator = 'start' | 'end' | 'hidden';
+export type PfRadioUi = Partial<{
+    root: string;
+    container: string;
+    base: string;
+    indicator: string;
+    dot: string;
+    wrapper: string;
+    label: string;
+    description: string;
+}>;
+type __VLS_Props = {
+    as?: string | Component;
+    /** Group selected value (`v-model`). */
+    modelValue?: unknown;
+    defaultValue?: unknown;
+    /** This option’s value. */
+    value: unknown;
+    label?: string;
+    description?: string;
+    color?: PfRadioColor;
+    variant?: PfRadioVariant;
+    size?: PfRadioSize;
+    indicator?: PfRadioIndicator;
+    ui?: PfRadioUi;
+    disabled?: boolean;
+    required?: boolean;
+    name?: string;
+    id?: string;
+    autofocus?: boolean;
+    form?: string;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        label?(_: {}): any;
+        label?(_: {}): any;
+        description?(_: {}): any;
+        description?(_: {}): any;
+    };
+    refs: {
+        inputRef: HTMLInputElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {
+    inputRef: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (event: Event) => any;
+    "update:modelValue": (value: unknown) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: ((event: Event) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: unknown) => any) | undefined;
+}>, {
+    size: PfRadioSize;
+    required: boolean;
+    color: PfRadioColor;
+    variant: PfRadioVariant;
+    disabled: boolean;
+    indicator: PfRadioIndicator;
+    autofocus: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    inputRef: HTMLInputElement;
+}, 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/form/PfRadioGroup/index.vue.d.ts

@@ -0,0 +1,74 @@
+import { Component } from 'vue';
+import { PfRadioColor, PfRadioIndicator, PfRadioSize, PfRadioVariant } from '../PfRadio/index.vue';
+import { PfChoiceGroupItem } from '../groupItems';
+export type PfRadioGroupUi = Partial<{
+    root: string;
+    fieldset: string;
+    legend: string;
+    item: string;
+    container: string;
+    base: string;
+    indicator: string;
+    dot: string;
+    wrapper: string;
+    label: string;
+    description: string;
+}>;
+type __VLS_Props = {
+    as?: string | Component;
+    legend?: string;
+    valueKey?: string;
+    labelKey?: string;
+    descriptionKey?: string;
+    items?: readonly PfChoiceGroupItem[];
+    modelValue?: unknown;
+    defaultValue?: unknown;
+    size?: PfRadioSize;
+    variant?: PfRadioVariant | 'table';
+    orientation?: 'horizontal' | 'vertical';
+    indicator?: PfRadioIndicator;
+    disabled?: boolean;
+    name?: string;
+    required?: boolean;
+    color?: PfRadioColor;
+    ui?: PfRadioGroupUi;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        legend?(_: {}): any;
+        label?(_: {
+            item: import('../groupItems').PfNormalizedChoiceItem;
+        }): any;
+        description?(_: {
+            item: import('../groupItems').PfNormalizedChoiceItem;
+        }): 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, {
+    change: (event: Event) => any;
+    "update:modelValue": (value: unknown) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: ((event: Event) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: unknown) => any) | undefined;
+}>, {
+    required: boolean;
+    color: PfRadioColor;
+    variant: PfRadioVariant | "table";
+    disabled: boolean;
+    orientation: "horizontal" | "vertical";
+    indicator: PfRadioIndicator;
+    valueKey: string;
+    labelKey: string;
+    descriptionKey: string;
+}, {}, {}, {}, 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/form/PfSelect/index.vue.d.ts

@@ -0,0 +1,209 @@
+import { PfIconName } from '../../element/PfIcon/paths';
+import { PfChipColor, PfChipSize } from '../../element/PfChip/index.vue';
+export type PfSelectColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'error' | 'neutral';
+export type PfSelectVariant = 'outline' | 'soft' | 'subtle' | 'ghost' | 'none';
+export type PfSelectSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type PfSelectOptionAvatarSize = '3xs' | '2xs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl';
+/** `PfAvatar` props to the left of the item (or via `imageSrc`). */
+export interface PfSelectOptionAvatarConfig {
+    src?: string;
+    alt?: string;
+    icon?: PfIconName;
+    text?: string;
+    size?: PfSelectOptionAvatarSize;
+}
+/** `PfChip` props (`standalone` mode) instead of plain label text. */
+export interface PfSelectOptionChipConfig {
+    color?: PfChipColor;
+    size?: PfChipSize;
+    show?: boolean;
+}
+export interface PfSelectOption {
+    value: string | number;
+    label: string;
+    disabled?: boolean;
+    /** Icon to the left of the label (if no `avatar` / `imageSrc`). */
+    icon?: PfIconName;
+    /** Image on the left (circular via `PfAvatar`). */
+    imageSrc?: string;
+    imageAlt?: string;
+    /** Avatar/icon/initials on the left; takes precedence over `imageSrc` and `icon`. */
+    avatar?: PfSelectOptionAvatarConfig;
+    /** Color indicator on the left (empty `PfChip`); label aligns with icon rows. */
+    chip?: PfSelectOptionChipConfig;
+    /** Selected-item icon in the panel for this option; `null` — hide. */
+    selectedIcon?: PfIconName | null;
+}
+/** Group item: string (`value` and label match) or full option. */
+export type PfSelectGroupItem = string | PfSelectOption;
+/** Option groups; flattened into one list, dividers between groups in the panel. */
+export type PfSelectOptionGroups = readonly (readonly PfSelectGroupItem[])[];
+export type PfSelectModelValue = string | number | undefined | (string | number)[];
+export interface PfSelectUi {
+    root?: string;
+    shell?: string;
+    native?: string;
+    trailing?: string;
+    icon?: string;
+    leading?: string;
+    leadingIcon?: string;
+    leadingAvatar?: string;
+    trigger?: string;
+    panel?: string;
+    option?: string;
+    optionLabel?: string;
+    optionIcon?: string;
+    optionLeading?: string;
+    optionChip?: string;
+    /** Divider between groups in the custom panel. */
+    groupDivider?: string;
+    /** Empty list after filtering (e.g. search). */
+    panelEmpty?: string;
+}
+type __VLS_Props = {
+    id?: string;
+    modelValue?: PfSelectModelValue;
+    defaultValue?: PfSelectModelValue;
+    options?: readonly PfSelectOption[];
+    /**
+     * Option groups (e.g. `[['A','B'], ['C']]`). Use instead of flat `options`;
+     * `v-model` still comes from option `value` fields or from the string when the item is a string.
+     */
+    optionGroups?: PfSelectOptionGroups;
+    /** `<optgroup>` labels in native mode by group index. */
+    optionGroupLabels?: readonly (string | undefined)[];
+    placeholder?: string;
+    multiple?: boolean;
+    /** Native `size` on `<select multiple>` — number of visible rows. */
+    listboxRows?: number;
+    /**
+     * Native `<select>`. Without `options` (slot) or with `native: true` — native UI;
+     * otherwise custom trigger and panel (single and multiple selection with `options`).
+     */
+    native?: boolean;
+    name?: string;
+    required?: boolean;
+    disabled?: boolean;
+    autocomplete?: string;
+    autofocus?: boolean;
+    form?: string;
+    color?: PfSelectColor;
+    variant?: PfSelectVariant;
+    size?: PfSelectSize;
+    highlight?: boolean;
+    /** Expand icon on the trigger (and native mode on the right). */
+    chevronIcon?: PfIconName;
+    /** @deprecated Use `chevronIcon`; if only this is set, behavior is unchanged. */
+    trailingIcon?: PfIconName;
+    /**
+     * Icon for the selected row in the panel (default for all options).
+     * Per-option `selectedIcon` overrides.
+     * `null` — hide globally (options with their own `selectedIcon` still show it).
+     */
+    selectedOptionIcon?: PfIconName | null;
+    /** Icon to the left of the field (custom and native UI). */
+    leadingIcon?: PfIconName;
+    /** Avatar on the left; hidden when `loading`, spinner shown. */
+    leadingAvatar?: PfSelectOptionAvatarConfig;
+    /** Loading: spinner on the left instead of `leadingIcon` / `leadingAvatar`. */
+    loading?: boolean;
+    /** Loading icon on the left. */
+    loadingIcon?: PfIconName;
+    /** Gap between panel and trigger (px). */
+    menuGap?: number;
+    /** Clear value: row in panel (single) or clear all (multi). */
+    clearable?: boolean;
+    /** Label for the clear row in the panel; default «—». */
+    clearOptionLabel?: string;
+    /** Initial panel open state (without external `v-model` on `PfSelect`). */
+    defaultOpen?: boolean;
+    /**
+     * Show the panel even when the option list is empty (e.g. search with no matches).
+     */
+    allowEmptyPanel?: boolean;
+    /**
+     * Hides panel rows; hidden rows stay in the native `<select>` for the form.
+     */
+    optionFilter?: (index: number, option: PfSelectOption) => boolean;
+    /**
+     * Text when filtering leaves no rows (empty `panelEmpty` slot overrides).
+     */
+    emptyText?: string;
+    /**
+     * After selecting an option in single mode, return focus to the trigger.
+     * For PfInputMenu set `false` to avoid leaving focus on the input field.
+     */
+    focusTriggerAfterSingleSelect?: boolean;
+    ui?: PfSelectUi;
+};
+declare function closePanel(): void;
+declare function openPanel(): void;
+declare function togglePanel(): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        leading?(_: {}): any;
+        leading?(_: {}): any;
+        trigger?(_: {
+            comboboxAttrs: Record<string, string | boolean | undefined>;
+            togglePanel: typeof togglePanel;
+            openPanel: typeof openPanel;
+            closePanel: typeof closePanel;
+        }): any;
+        panelTop?(_: {}): any;
+        panelEmpty?(_: {}): any;
+        default?(_: {}): any;
+    };
+    refs: {
+        shellRef: HTMLDivElement;
+        triggerRef: HTMLDivElement;
+        selectRef: HTMLSelectElement;
+        panelRef: HTMLDivElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {
+    selectRef: import('vue').Ref<HTMLSelectElement | null, HTMLSelectElement | null>;
+    triggerRef: import('vue').Ref<HTMLButtonElement | null, HTMLButtonElement | null>;
+    panelRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    open: typeof openPanel;
+    close: typeof closePanel;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    blur: (event: FocusEvent) => any;
+    change: (event: Event) => any;
+    "update:modelValue": (value: PfSelectModelValue) => any;
+    "update:menuOpen": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onChange?: ((event: Event) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: PfSelectModelValue) => any) | undefined;
+    "onUpdate:menuOpen"?: ((value: boolean) => any) | undefined;
+}>, {
+    required: boolean;
+    loading: boolean;
+    color: PfSelectColor;
+    variant: PfSelectVariant;
+    disabled: boolean;
+    multiple: boolean;
+    autocomplete: string;
+    highlight: boolean;
+    native: boolean;
+    menuGap: number;
+    clearable: boolean;
+    allowEmptyPanel: boolean;
+    emptyText: string;
+    focusTriggerAfterSingleSelect: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    shellRef: HTMLDivElement;
+    triggerRef: HTMLDivElement;
+    selectRef: HTMLSelectElement;
+    panelRef: HTMLDivElement;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};