prismify-ui 0.1.0-alpha.1

package/dist/components/form/PfCalendar/calendarGrid.d.ts

@@ -0,0 +1,12 @@
+import { DateValue } from '@internationalized/date';
+/** Matches `@internationalized/date` week start names (not exported from the package). */
+export type PfCalendarWeekStartsOn = 'sun' | 'mon' | 'tue' | 'wed' | 'thu' | 'fri' | 'sat';
+export type PfCalendarWeekRow = {
+    /** ISO-like week number for the row (from first day of week). */
+    weekNumber?: number;
+    days: DateValue[];
+};
+/** ISO 8601 week number for the calendar week containing `date`. */
+export declare function getIsoWeekNumber(date: DateValue, timeZone: string): number;
+export declare function buildMonthGrid(visibleMonth: DateValue, locale: string, weekStartsOn: PfCalendarWeekStartsOn | undefined, fixedWeeks: boolean, includeWeekNumbers: boolean, timeZone: string): PfCalendarWeekRow[];
+export declare function shiftVisibleMonth(anchor: DateValue, deltaMonths: number): DateValue;

package/dist/components/form/PfCalendar/calendarSelection.d.ts

@@ -0,0 +1,30 @@
+import { DateValue } from '@internationalized/date';
+export type PfCalendarDateRange = {
+    start?: DateValue | null;
+    end?: DateValue | null;
+};
+export type PfCalendarMatcher = (date: DateValue) => boolean;
+export declare function applySingleClick(current: DateValue | null | undefined, day: DateValue, options: {
+    preventDeselect: boolean;
+    minValue?: DateValue | null;
+    maxValue?: DateValue | null;
+}): DateValue | null;
+export declare function applyMultipleClick(list: DateValue[], day: DateValue, options: {
+    minValue?: DateValue | null;
+    maxValue?: DateValue | null;
+}): DateValue[];
+export declare function applyRangeClick(range: PfCalendarDateRange, day: DateValue, options: {
+    minValue?: DateValue | null;
+    maxValue?: DateValue | null;
+    maximumDays?: number | undefined;
+    isDateUnavailable?: PfCalendarMatcher | undefined;
+    allowNonContiguousRanges: boolean;
+    preventDeselect: boolean;
+    fixedDate?: 'start' | 'end';
+}): PfCalendarDateRange;
+export declare function isDayInRange(day: DateValue, range: PfCalendarDateRange): {
+    selected: boolean;
+    rangeStart: boolean;
+    rangeEnd: boolean;
+    inRange: boolean;
+};

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

@@ -0,0 +1,137 @@
+import { Component } from 'vue';
+import { DateValue } from '@internationalized/date';
+import { PfIconName } from '../../element/PfIcon/paths';
+import { PfCalendarWeekStartsOn } from './calendarGrid';
+import { PfCalendarDateRange, PfCalendarMatcher } from './calendarSelection';
+export type { PfCalendarDateRange, PfCalendarMatcher, } from './calendarSelection';
+export type { PfCalendarWeekStartsOn } from './calendarGrid';
+export type PfCalendarColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'error' | 'neutral';
+export type PfCalendarVariant = 'solid' | 'outline' | 'soft' | 'subtle';
+export type PfCalendarSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type PfCalendarWeekdayFormat = 'narrow' | 'short' | 'long';
+export type PfCalendarModelValue = DateValue | null | DateValue[] | PfCalendarDateRange;
+export type PfCalendarUi = {
+    root?: string | string[];
+    header?: string | string[];
+    body?: string | string[];
+    heading?: string | string[];
+    grid?: string | string[];
+    gridRow?: string | string[];
+    gridWeekDaysRow?: string | string[];
+    gridBody?: string | string[];
+    headCell?: string | string[];
+    headCellWeek?: string | string[];
+    cell?: string | string[];
+    cellTrigger?: string | string[];
+    cellWeek?: string | string[];
+};
+type __VLS_Props = {
+    as?: string | Component;
+    color?: PfCalendarColor;
+    variant?: PfCalendarVariant;
+    size?: PfCalendarSize;
+    range?: boolean;
+    multiple?: boolean;
+    monthControls?: boolean;
+    yearControls?: boolean;
+    fixedWeeks?: boolean;
+    weekNumbers?: boolean;
+    numberOfMonths?: number;
+    disabled?: boolean;
+    readonly?: boolean;
+    initialFocus?: boolean;
+    /** BCP 47 locale for month/weekday labels (passed to `DateFormatter`). */
+    locale?: string;
+    weekdayFormat?: PfCalendarWeekdayFormat;
+    weekStartsOn?: PfCalendarWeekStartsOn;
+    pagedNavigation?: boolean;
+    preventDeselect?: boolean;
+    maximumDays?: number;
+    allowNonContiguousRanges?: boolean;
+    fixedDate?: 'start' | 'end';
+    disableDaysOutsideCurrentView?: boolean;
+    modelValue?: PfCalendarModelValue | null;
+    defaultValue?: PfCalendarModelValue | null;
+    placeholder?: DateValue | null;
+    defaultPlaceholder?: DateValue | null;
+    minValue?: DateValue | null;
+    maxValue?: DateValue | null;
+    isDateDisabled?: PfCalendarMatcher;
+    isDateUnavailable?: PfCalendarMatcher;
+    isDateHighlightable?: PfCalendarMatcher;
+    nextPage?: (placeholder: DateValue) => DateValue;
+    prevPage?: (placeholder: DateValue) => DateValue;
+    ui?: PfCalendarUi;
+    prevYearIcon?: PfIconName;
+    nextYearIcon?: PfIconName;
+    prevMonthIcon?: PfIconName;
+    nextMonthIcon?: PfIconName;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        heading?(_: {
+            months: DateValue[];
+        }): any;
+        'week-day'?(_: {
+            label: string;
+            index: number;
+        }): any;
+        day?(_: {
+            day: DateValue;
+        }): any;
+    };
+    refs: {
+        rootEl: unknown;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {
+    focus: () => void | undefined;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: PfCalendarModelValue) => any;
+    "update:placeholder": (value: DateValue) => any;
+    "update:validModelValue": (value: PfCalendarDateRange) => any;
+    "update:startValue": (value: DateValue | undefined) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: PfCalendarModelValue) => any) | undefined;
+    "onUpdate:placeholder"?: ((value: DateValue) => any) | undefined;
+    "onUpdate:validModelValue"?: ((value: PfCalendarDateRange) => any) | undefined;
+    "onUpdate:startValue"?: ((value: DateValue | undefined) => any) | undefined;
+}>, {
+    size: PfCalendarSize;
+    as: string | Component;
+    color: PfCalendarColor;
+    variant: PfCalendarVariant;
+    disabled: boolean;
+    range: boolean;
+    multiple: boolean;
+    monthControls: boolean;
+    yearControls: boolean;
+    fixedWeeks: boolean;
+    weekNumbers: boolean;
+    numberOfMonths: number;
+    readonly: boolean;
+    initialFocus: boolean;
+    locale: string;
+    weekdayFormat: PfCalendarWeekdayFormat;
+    weekStartsOn: PfCalendarWeekStartsOn;
+    pagedNavigation: boolean;
+    preventDeselect: boolean;
+    allowNonContiguousRanges: boolean;
+    disableDaysOutsideCurrentView: boolean;
+    prevYearIcon: PfIconName;
+    nextYearIcon: PfIconName;
+    prevMonthIcon: PfIconName;
+    nextMonthIcon: PfIconName;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    rootEl: unknown;
+}, 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/PfCheckbox/index.vue.d.ts

@@ -0,0 +1,84 @@
+import { Component } from 'vue';
+import { PfIconName } from '../../element/PfIcon/paths';
+export type PfCheckboxColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'error' | 'neutral';
+export type PfCheckboxVariant = 'card' | 'list';
+export type PfCheckboxSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type PfCheckboxIndicator = 'start' | 'end' | 'hidden';
+export type PfCheckboxUi = Partial<{
+    root: string;
+    container: string;
+    base: string;
+    indicator: string;
+    icon: string;
+    wrapper: string;
+    label: string;
+    description: string;
+}>;
+type __VLS_Props = {
+    /** Root tag or component. Default `label` (whole hit area is clickable). */
+    as?: string | Component;
+    modelValue?: unknown;
+    /** Initial value without `v-model`. */
+    defaultValue?: boolean | 'indeterminate';
+    trueValue?: unknown;
+    falseValue?: unknown;
+    label?: string;
+    description?: string;
+    color?: PfCheckboxColor;
+    variant?: PfCheckboxVariant;
+    size?: PfCheckboxSize;
+    indicator?: PfCheckboxIndicator;
+    icon?: PfIconName;
+    indeterminateIcon?: PfIconName;
+    ui?: PfCheckboxUi;
+    disabled?: boolean;
+    required?: boolean;
+    name?: string;
+    /** Value submitted when checked (`input[value]`). */
+    value?: string | number;
+    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: PfCheckboxSize;
+    required: boolean;
+    icon: PfIconName;
+    color: PfCheckboxColor;
+    variant: PfCheckboxVariant;
+    disabled: boolean;
+    indicator: PfCheckboxIndicator;
+    indeterminateIcon: PfIconName;
+    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/PfCheckboxGroup/index.vue.d.ts

@@ -0,0 +1,82 @@
+import { Component } from 'vue';
+import { PfCheckboxColor, PfCheckboxIndicator, PfCheckboxSize, PfCheckboxVariant } from '../PfCheckbox/index.vue';
+import { PfIconName } from '../../element/PfIcon/paths';
+import { PfChoiceGroupItem } from '../groupItems';
+export type PfCheckboxGroupUi = Partial<{
+    root: string;
+    fieldset: string;
+    legend: string;
+    item: string;
+    container: string;
+    base: string;
+    indicator: string;
+    icon: 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?: PfCheckboxSize;
+    variant?: PfCheckboxVariant | 'table';
+    orientation?: 'horizontal' | 'vertical';
+    indicator?: PfCheckboxIndicator;
+    disabled?: boolean;
+    loop?: boolean;
+    name?: string;
+    required?: boolean;
+    color?: PfCheckboxColor;
+    icon?: PfIconName;
+    ui?: PfCheckboxGroupUi;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        legend?(_: {}): any;
+        label?(_: {
+            item: import('../groupItems').PfNormalizedChoiceItem;
+        }): any;
+        description?(_: {
+            item: import('../groupItems').PfNormalizedChoiceItem;
+        }): any;
+    };
+    refs: {
+        fieldsetRef: HTMLFieldSetElement;
+    };
+    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: PfCheckboxColor;
+    variant: PfCheckboxVariant | "table";
+    disabled: boolean;
+    orientation: "horizontal" | "vertical";
+    indicator: PfCheckboxIndicator;
+    valueKey: string;
+    labelKey: string;
+    descriptionKey: string;
+    loop: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    fieldsetRef: HTMLFieldSetElement;
+}, 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/PfColorPicker/colorPicker.d.ts

@@ -0,0 +1,46 @@
+/** Internal HSV (Nuxt UI ColorPicker style): h — degrees 0–360, s/v — percent 0–100. */
+export interface PfColorPickerHsv {
+    h: number;
+    s: number;
+    v: number;
+}
+export type PfColorPickerFormat = 'hex' | 'rgb' | 'hsl' | 'cmyk' | 'lab';
+export interface Rgb {
+    r: number;
+    g: number;
+    b: number;
+}
+/** HSL (H 0–360, S/L 0–100) → HSV (Nuxt-compatible formulas). */
+export declare function hslToHsv(h: number, s: number, l: number): PfColorPickerHsv;
+/** HSV → HSL (Nuxt). */
+export declare function hsvToHsl(hsv: PfColorPickerHsv): {
+    h: number;
+    s: number;
+    l: number;
+};
+export declare function rgbToHsv(r: number, g: number, b: number): PfColorPickerHsv;
+export declare function hsvToRgb(hsv: PfColorPickerHsv): Rgb;
+/** sRGB 0–255 → XYZ (D65), Y scaled to 0–100 for Lab. */
+export declare function rgbToXyz(r: number, g: number, b: number): {
+    x: number;
+    y: number;
+    z: number;
+};
+export declare function rgbToLab(r: number, g: number, b: number): {
+    l: number;
+    a: number;
+    b: number;
+};
+export declare function labToRgb(l: number, a: number, b: number): Rgb;
+export declare function rgbToCmyk(r: number, g: number, b: number): {
+    c: number;
+    m: number;
+    y: number;
+    k: number;
+};
+export declare function cmykToRgb(c: number, m: number, y: number, k: number): Rgb;
+/** Parse a color string to sRGB 0–255; on error — `fallback`. */
+export declare function parseColorToRgb(input: string | undefined, fallback?: Rgb): Rgb;
+export declare function formatColorFromRgb(rgb: Rgb, format: PfColorPickerFormat): string;
+export declare function colorStringToHsv(input: string | undefined, fallbackRgb?: Rgb): PfColorPickerHsv;
+export declare function hsvToColorString(hsv: PfColorPickerHsv, format: PfColorPickerFormat): string;

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

@@ -0,0 +1,54 @@
+import { Component } from 'vue';
+import { PfColorPickerFormat } from './colorPicker';
+export type PfColorPickerSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type PfColorPickerUi = Partial<{
+    root: string;
+    picker: string;
+    selector: string;
+    selectorBackground: string;
+    selectorThumb: string;
+    track: string;
+    trackThumb: string;
+}>;
+type __VLS_Props = {
+    as?: string | Component;
+    modelValue?: string;
+    defaultValue?: string;
+    format?: PfColorPickerFormat;
+    throttle?: number;
+    disabled?: boolean;
+    size?: PfColorPickerSize;
+    ui?: PfColorPickerUi;
+    /** Undo/redo history (Ctrl/Cmd+Z, Ctrl/Cmd+Y / Ctrl+Shift+Z). */
+    history?: boolean;
+    /** Debounce writing a stage to history (ms): while dragging, do not log every step. */
+    historyDebounce?: number;
+    /** Max undo stack length. */
+    historyLimit?: number;
+};
+declare function undo(): void;
+declare function redo(): void;
+declare const _default: import('vue').DefineComponent<__VLS_Props, {
+    undo: typeof undo;
+    redo: typeof redo;
+    canUndo: import('vue').ComputedRef<boolean>;
+    canRedo: import('vue').ComputedRef<boolean>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    size: PfColorPickerSize;
+    disabled: boolean;
+    defaultValue: string;
+    format: PfColorPickerFormat;
+    throttle: number;
+    history: boolean;
+    historyDebounce: number;
+    historyLimit: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    rootRef: unknown;
+    selectorRef: HTMLDivElement;
+    trackRef: HTMLDivElement;
+}, any>;
+export default _default;