prismify-ui 0.1.0-alpha.1

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

@@ -0,0 +1,258 @@
+import { PfIconName } from '../../element/PfIcon/paths';
+export type PfFileUploadColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'error' | 'neutral';
+export type PfFileUploadUi = Partial<{
+    root: string;
+    base: string;
+    wrapper: string;
+    icon: string;
+    avatar: string;
+    label: string;
+    description: string;
+    actions: string;
+    files: string;
+    file: string;
+    fileLeadingAvatar: string;
+    fileWrapper: string;
+    fileName: string;
+    fileSize: string;
+    fileTrailingButton: string;
+}>;
+export type PfFileUploadFileDeleteConfig = {
+    color?: PfFileUploadColor;
+    variant?: 'solid' | 'outline' | 'soft' | 'subtle' | 'ghost' | 'link';
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    iconOnly?: boolean;
+};
+export type PfFileUploadInvalidCode = 'accept' | 'maxSize';
+export type PfFileUploadInvalidPayload = {
+    code: PfFileUploadInvalidCode;
+    file: File;
+    message: string;
+};
+type __VLS_Props = {
+    as?: string | Record<string, unknown>;
+    id?: string;
+    name?: string;
+    label?: string;
+    description?: string;
+    color?: PfFileUploadColor;
+    /** `button` only when `multiple === false`. */
+    variant?: 'button' | 'area';
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    /** Only when `variant="area"`. */
+    layout?: 'list' | 'grid';
+    /** Only when `variant="area"` and `layout="list"`. */
+    position?: 'inside' | 'outside';
+    highlight?: boolean;
+    /** Max file size in kibibytes (KiB, 1 KiB = 1024 bytes). */
+    maxSize?: number;
+    /** External error text (overrides internal). */
+    error?: string;
+    /** Custom wrong-type error template: `{name}`, `{accept}` available. */
+    acceptErrorText?: string;
+    /** Custom max-size error template: `{name}`, `{max}` (human-readable limit). */
+    maxSizeErrorText?: string;
+    accept?: string;
+    multiple?: boolean;
+    /** Reset `<input>` value before opening the dialog (same file again). */
+    reset?: boolean;
+    dropzone?: boolean;
+    interactive?: boolean;
+    required?: boolean;
+    disabled?: boolean;
+    /** Zone (area) / button icon. */
+    icon?: PfIconName;
+    /** Icon in file row (list) or when preview is off. */
+    fileIcon?: PfIconName;
+    /** Show `<img>` for images in preview. */
+    fileImage?: boolean;
+    /** `false` — hide the component file list/grid. */
+    preview?: boolean;
+    /** File delete: `true` / `false` or `PfButton` settings. */
+    fileDelete?: boolean | PfFileUploadFileDeleteConfig;
+    fileDeleteIcon?: PfIconName;
+    modelValue?: File | File[] | null;
+    defaultValue?: File | File[] | null;
+    ui?: PfFileUploadUi;
+    form?: string;
+    formaction?: string;
+    formenctype?: string;
+    formmethod?: string;
+    formnovalidate?: boolean;
+    formtarget?: string;
+};
+declare function open(): void;
+declare function removeFile(file?: File): void;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            open: typeof open;
+            removeFile: typeof removeFile;
+            files: File[];
+        }): any;
+        actions?(_: {
+            open: typeof open;
+        }): any;
+        actions?(_: {
+            open: typeof open;
+        }): any;
+        leading?(_: {}): any;
+        leading?(_: {}): any;
+        file?(_: {
+            file: File;
+            index: number;
+            removeFile: typeof removeFile;
+        }): any;
+        file?(_: {
+            file: File;
+            index: number;
+            removeFile: typeof removeFile;
+        }): any;
+        file?(_: {
+            file: File;
+            index: number;
+            removeFile: typeof removeFile;
+        }): any;
+        file?(_: {
+            file: File;
+            index: number;
+            removeFile: typeof removeFile;
+        }): any;
+        file?(_: {
+            file: File;
+            index: number;
+            removeFile: typeof removeFile;
+        }): any;
+        'file-leading'?(_: {
+            file: File;
+        }): any;
+        'file-leading'?(_: {
+            file: File;
+        }): any;
+        'file-leading'?(_: {
+            file: File;
+        }): any;
+        'file-leading'?(_: {
+            file: File;
+        }): any;
+        'file-leading'?(_: {
+            file: File;
+        }): any;
+        'file-name'?(_: {
+            file: File;
+        }): any;
+        'file-name'?(_: {
+            file: File;
+        }): any;
+        'file-name'?(_: {
+            file: File;
+        }): any;
+        'file-size'?(_: {
+            file: File;
+        }): any;
+        'file-size'?(_: {
+            file: File;
+        }): any;
+        'file-size'?(_: {
+            file: File;
+        }): any;
+        'file-trailing'?(_: {
+            file: File;
+            removeFile: typeof removeFile;
+        }): any;
+        'file-trailing'?(_: {
+            file: File;
+            removeFile: typeof removeFile;
+        }): any;
+        'file-trailing'?(_: {
+            file: File;
+            removeFile: typeof removeFile;
+        }): any;
+        'file-trailing'?(_: {
+            file: File;
+            removeFile: typeof removeFile;
+        }): any;
+        'file-trailing'?(_: {
+            file: File;
+            removeFile: typeof removeFile;
+        }): any;
+        'files-top'?(_: {
+            open: typeof open;
+            files: File[];
+        }): any;
+        files?(_: {
+            files: File[];
+            open: typeof open;
+            removeFile: typeof removeFile;
+        }): any;
+        files?(_: {
+            files: File[];
+            open: typeof open;
+            removeFile: typeof removeFile;
+        }): any;
+        files?(_: {
+            files: File[];
+            open: typeof open;
+            removeFile: typeof removeFile;
+        }): any;
+        files?(_: {
+            files: File[];
+            open: typeof open;
+            removeFile: typeof removeFile;
+        }): any;
+        label?(_: {}): any;
+        description?(_: {}): any;
+        'files-bottom'?(_: {
+            open: typeof open;
+            removeFile: typeof removeFile;
+            files: File[];
+        }): any;
+    };
+    refs: {
+        dropzoneRef: unknown;
+        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>;
+    dropzoneRef: import('vue').Ref<HTMLElement | null, HTMLElement | null>;
+    open: typeof open;
+    removeFile: typeof removeFile;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    change: (event: Event) => any;
+    invalid: (payload: PfFileUploadInvalidPayload) => any;
+    "update:modelValue": (value: File | File[] | null) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onChange?: ((event: Event) => any) | undefined;
+    onInvalid?: ((payload: PfFileUploadInvalidPayload) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: File | File[] | null) => any) | undefined;
+}>, {
+    fileDelete: boolean | PfFileUploadFileDeleteConfig;
+    interactive: boolean;
+    size: "xs" | "sm" | "md" | "lg" | "xl";
+    color: PfFileUploadColor;
+    reset: boolean;
+    variant: "button" | "area";
+    position: "inside" | "outside";
+    multiple: boolean;
+    highlight: boolean;
+    layout: "list" | "grid";
+    accept: string;
+    dropzone: boolean;
+    fileImage: boolean;
+    preview: boolean;
+    fileDeleteIcon: PfIconName;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    dropzoneRef: unknown;
+    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/PfForm/index.vue.d.ts

@@ -0,0 +1,75 @@
+import { PfFormError, PfFormInputEvent, PfFormValidateOptions } from './injection';
+export type PfFormSubmitEvent<T = unknown> = {
+    data: T;
+};
+export type PfFormErrorEvent = {
+    errors: PfFormError[];
+};
+export type PfFormUi = Partial<{
+    base: string;
+}>;
+type __VLS_Props = {
+    id?: string | number;
+    schema?: unknown;
+    state?: Record<string, unknown>;
+    validate?: ((state: Record<string, unknown>) => PfFormError[] | Promise<PfFormError[]>) | undefined;
+    validateOn?: PfFormInputEvent[];
+    disabled?: boolean;
+    name?: string;
+    validateOnInputDelay?: number;
+    transform?: boolean;
+    nested?: boolean;
+    loadingAuto?: boolean;
+    ui?: PfFormUi;
+};
+declare function setErrors(nextErrors: PfFormError[], path?: string | RegExp): void;
+declare function clear(path?: string | RegExp): void;
+declare function getErrors(path?: string | RegExp): PfFormError[];
+declare function runValidation(opts?: PfFormValidateOptions): Promise<unknown>;
+declare function submit(): Promise<void>;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        rootRef: unknown;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {
+    submit: typeof submit;
+    validate: typeof runValidation;
+    clear: typeof clear;
+    getErrors: typeof getErrors;
+    setErrors: typeof setErrors;
+    errors: Readonly<import('vue').Ref<readonly PfFormError<string>[], readonly PfFormError<string>[]>>;
+    disabled: Readonly<import('vue').Ref<boolean, boolean>>;
+    dirty: import('vue').ComputedRef<boolean>;
+    dirtyFields: Readonly<import('vue').Ref<ReadonlySet<string>, ReadonlySet<string>>>;
+    touchedFields: Readonly<import('vue').Ref<ReadonlySet<string>, ReadonlySet<string>>>;
+    blurredFields: Readonly<import('vue').Ref<ReadonlySet<string>, ReadonlySet<string>>>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    error: (event: PfFormErrorEvent) => any;
+    submit: (event: PfFormSubmitEvent<unknown>) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onError?: ((event: PfFormErrorEvent) => any) | undefined;
+    onSubmit?: ((event: PfFormSubmitEvent<unknown>) => any) | undefined;
+}>, {
+    transform: boolean;
+    disabled: boolean;
+    loadingAuto: boolean;
+    validateOn: PfFormInputEvent[];
+    validateOnInputDelay: number;
+    nested: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    rootRef: 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/PfForm/injection.d.ts

@@ -0,0 +1,32 @@
+import { Ref, InjectionKey } from 'vue';
+export type PfFormInputEvent = 'input' | 'change' | 'blur';
+export type PfFormError<TName extends string = string> = {
+    id?: string;
+    name: TName;
+    message: string;
+};
+export type PfFormValidateOptions = {
+    name?: string | string[];
+    silent?: boolean;
+    nested?: boolean;
+    transform?: boolean;
+};
+export type PfFormContextValue = {
+    pathPrefix: string;
+    state: Readonly<Ref<unknown>>;
+    errors: Ref<PfFormError[]>;
+    disabled: Ref<boolean>;
+    getError: (name?: string, pattern?: RegExp) => PfFormError | undefined;
+    clear: (path?: string | RegExp) => void;
+    markFieldInteraction: (name: string, event: PfFormInputEvent) => void;
+    validate: (opts?: PfFormValidateOptions) => Promise<unknown>;
+    registerNested: (entry: {
+        validate: (opts?: PfFormValidateOptions) => Promise<unknown>;
+        clear: (path?: string | RegExp) => void;
+    }) => void;
+    unregisterNested: (entry: {
+        validate: (opts?: PfFormValidateOptions) => Promise<unknown>;
+        clear: (path?: string | RegExp) => void;
+    }) => void;
+};
+export declare const PF_FORM_INJECTION_KEY: InjectionKey<PfFormContextValue>;

package/dist/components/form/PfForm/validation.d.ts

@@ -0,0 +1,9 @@
+import { PfFormError } from './injection';
+type ValidationResult = {
+    data: unknown;
+    errors: PfFormError[];
+};
+export declare function filterErrorsByName(errors: PfFormError[], name?: string | string[]): PfFormError[];
+export declare function runSchemaValidation(schema: unknown, data: unknown): Promise<ValidationResult>;
+export declare function runCustomValidation(validate: ((state: Record<string, unknown>) => PfFormError[] | Promise<PfFormError[]>) | undefined, data: Record<string, unknown>): Promise<PfFormError[]>;
+export {};

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

@@ -0,0 +1,59 @@
+import { Component } from 'vue';
+export type PfFormFieldSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type PfFormFieldOrientation = 'vertical' | 'horizontal';
+export type PfFormFieldUi = Partial<{
+    root: string;
+    wrapper: string;
+    labelWrapper: string;
+    label: string;
+    container: string;
+    description: string;
+    error: string;
+    hint: string;
+    help: string;
+}>;
+type __VLS_Props = {
+    as?: string | Component;
+    name?: string;
+    errorPattern?: RegExp;
+    label?: string;
+    description?: string;
+    help?: string;
+    error?: string | boolean;
+    hint?: string;
+    size?: PfFormFieldSize;
+    required?: boolean;
+    eagerValidation?: boolean;
+    validateOnInputDelay?: number;
+    orientation?: PfFormFieldOrientation;
+    ui?: PfFormFieldUi;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        label?(_: {}): any;
+        hint?(_: {}): any;
+        description?(_: {}): any;
+        error?(_: {}): any;
+        help?(_: {}): 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, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    size: PfFormFieldSize;
+    required: boolean;
+    error: string | boolean;
+    as: string | Component;
+    orientation: PfFormFieldOrientation;
+    validateOnInputDelay: number;
+    eagerValidation: boolean;
+}, {}, {}, {}, 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/PfInput/index.vue.d.ts

@@ -0,0 +1,97 @@
+import { PfButtonAvatarProps } from '../../element/PfButton/index.vue';
+import { PfIconName } from '../../element/PfIcon/paths';
+export type PfInputColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'error' | 'neutral';
+export type PfInputVariant = 'outline' | 'soft' | 'subtle' | 'ghost' | 'none';
+export type PfInputUi = Partial<{
+    root: string;
+    base: string;
+    valueCell: string;
+    leading: string;
+    leadingIcon: string;
+    leadingAvatar: string;
+    trailing: string;
+    trailingIcon: string;
+}>;
+type __VLS_Props = {
+    id?: string;
+    name?: string;
+    type?: string;
+    placeholder?: string;
+    color?: PfInputColor;
+    variant?: PfInputVariant;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    required?: boolean;
+    autocomplete?: string;
+    autofocus?: boolean;
+    disabled?: boolean;
+    readonly?: boolean;
+    highlight?: boolean;
+    /** If `false`, font size steps down slightly on wide viewports (Nuxt UI `fixed: false` style). */
+    fixed?: boolean;
+    /** Smooth character appear and “drop” on delete (text types only). On by default. */
+    animatedText?: boolean;
+    ui?: PfInputUi;
+    icon?: PfIconName;
+    avatar?: PfButtonAvatarProps;
+    leading?: boolean;
+    leadingIcon?: PfIconName;
+    trailing?: boolean;
+    trailingIcon?: PfIconName;
+    loading?: boolean;
+    loadingIcon?: PfIconName;
+    maxlength?: number;
+    minlength?: number;
+    pattern?: string;
+    list?: string;
+    form?: string;
+    enterKeyHint?: 'search' | 'enter' | 'done' | 'go' | 'next' | 'previous' | 'send';
+};
+type __VLS_PublicProps = {
+    modelValue?: string;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        leading?(_: {}): any;
+        default?(_: {}): any;
+        trailing?(_: {}): any;
+    };
+    refs: {
+        valueCellRef: HTMLDivElement;
+        inputRef: HTMLInputElement;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {
+    inputRef: import('vue').Ref<HTMLInputElement | null, HTMLInputElement | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    blur: (event: FocusEvent) => any;
+    change: (event: Event) => any;
+    "update:modelValue": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onChange?: ((event: Event) => any) | undefined;
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    fixed: boolean;
+    type: string;
+    loading: boolean;
+    color: PfInputColor;
+    variant: PfInputVariant;
+    disabled: boolean;
+    readonly: boolean;
+    autocomplete: string;
+    highlight: boolean;
+    animatedText: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    valueCellRef: HTMLDivElement;
+    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/PfInputDate/index.vue.d.ts

@@ -0,0 +1,109 @@
+import { Component } from 'vue';
+import { DateValue } from '@internationalized/date';
+import { PfButtonAvatarProps } from '../../element/PfButton/index.vue';
+import { PfIconName } from '../../element/PfIcon/paths';
+import { PfCalendarDateRange, PfCalendarMatcher } from '../PfCalendar/calendarSelection';
+import { PfInputDateGranularity, PfInputDateHourCycle } from './inputDateSegments';
+export type PfInputDateColor = 'primary' | 'secondary' | 'success' | 'info' | 'warning' | 'error' | 'neutral';
+export type PfInputDateVariant = 'outline' | 'soft' | 'subtle' | 'ghost' | 'none';
+export type PfInputDateUi = Partial<{
+    root: string;
+    base: string;
+    leading: string;
+    leadingIcon: string;
+    leadingAvatar: string;
+    trailing: string;
+    trailingIcon: string;
+    segment: string;
+    separatorIcon: string;
+}>;
+export type PfInputDateModel = DateValue | null | PfCalendarDateRange;
+type __VLS_Props = {
+    as?: string | Component;
+    id?: string;
+    name?: string;
+    color?: PfInputDateColor;
+    variant?: PfInputDateVariant;
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    highlight?: boolean;
+    fixed?: boolean;
+    autofocus?: boolean;
+    autofocusDelay?: number;
+    range?: boolean;
+    locale?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    required?: boolean;
+    minValue?: DateValue | null;
+    maxValue?: DateValue | null;
+    isDateUnavailable?: PfCalendarMatcher;
+    defaultValue?: PfInputDateModel | null;
+    placeholder?: DateValue | null;
+    defaultPlaceholder?: DateValue | null;
+    granularity?: PfInputDateGranularity;
+    hourCycle?: PfInputDateHourCycle;
+    hideTimeZone?: boolean;
+    step?: number;
+    icon?: PfIconName;
+    avatar?: PfButtonAvatarProps;
+    leading?: boolean;
+    leadingIcon?: PfIconName;
+    trailing?: boolean;
+    trailingIcon?: PfIconName;
+    loading?: boolean;
+    loadingIcon?: PfIconName;
+    separatorIcon?: PfIconName;
+    ui?: PfInputDateUi;
+};
+type __VLS_PublicProps = {
+    modelValue?: PfInputDateModel | null;
+} & __VLS_Props;
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        leading?(_: {}): any;
+        separator?(_: {}): any;
+        trailing?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_PublicProps, {
+    inputsRef: import('vue').Ref<(HTMLInputElement | null)[], (HTMLInputElement | null)[]>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    blur: (event: FocusEvent) => any;
+    change: (event: Event) => any;
+    focus: (event: FocusEvent) => any;
+    "update:modelValue": (...args: unknown[]) => any;
+    "update:placeholder": (value: DateValue) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onBlur?: ((event: FocusEvent) => any) | undefined;
+    onChange?: ((event: Event) => any) | undefined;
+    onFocus?: ((event: FocusEvent) => any) | undefined;
+    "onUpdate:modelValue"?: ((...args: unknown[]) => any) | undefined;
+    "onUpdate:placeholder"?: ((value: DateValue) => any) | undefined;
+}>, {
+    fixed: boolean;
+    required: boolean;
+    as: string | Component;
+    loading: boolean;
+    color: PfInputDateColor;
+    variant: PfInputDateVariant;
+    disabled: boolean;
+    step: number;
+    range: boolean;
+    readonly: boolean;
+    autofocus: boolean;
+    highlight: boolean;
+    autofocusDelay: number;
+    hideTimeZone: boolean;
+    separatorIcon: PfIconName;
+}, {}, {}, {}, 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/PfInputDate/inputDateSegments.d.ts

@@ -0,0 +1,36 @@
+import { DateValue, CalendarDate, DateFormatter, ZonedDateTime } from '@internationalized/date';
+export type PfInputDateGranularity = 'day' | 'hour' | 'minute' | 'second';
+export type PfInputDateHourCycle = 'h11' | 'h12' | 'h23' | 'h24';
+export type PfInputDateLayoutToken = {
+    kind: 'literal';
+    text: string;
+} | {
+    kind: 'field';
+    partType: Intl.DateTimeFormatPart['type'];
+    key: string;
+};
+export declare function buildIntlDateOptions(granularity: PfInputDateGranularity, hourCycle: PfInputDateHourCycle | undefined, hideTimeZone: boolean): Intl.DateTimeFormatOptions;
+export declare function inferGranularity(value: DateValue | null | undefined, explicit: PfInputDateGranularity | undefined): PfInputDateGranularity;
+export declare function dateValueToJsDate(value: DateValue, timeZone: string): Date;
+export declare function layoutAndTextsFromDate(formatter: DateFormatter, jsDate: Date): {
+    layout: PfInputDateLayoutToken[];
+    texts: Record<string, string>;
+};
+export type ComposeResult = {
+    value: DateValue | null;
+    /** All editable fields filled (digits); value may still be invalid for the calendar. */
+    segmentsComplete: boolean;
+    /** Value assembled and passed constrain. */
+    valid: boolean;
+};
+export declare function tryComposeFromTexts(layout: PfInputDateLayoutToken[], texts: Record<string, string>, granularity: PfInputDateGranularity, timeZone: string, priorZoned: ZonedDateTime | null): ComposeResult;
+export declare function toComparableCalendarDate(v: DateValue | null): CalendarDate | null;
+export declare function withSameTimeZone(next: DateValue, previous: DateValue | null): DateValue;
+/**
+ * Shifts one date/time field (up/down arrows). Day/month/year — via `add`, not cycling within the month.
+ */
+export declare function nudgeDateSegment(base: DateValue, partType: string, direction: 1 | -1, options: {
+    granularity: PfInputDateGranularity;
+    step: number;
+}): DateValue | null;
+export declare function finalizeNudgedValue(next: DateValue, original: DateValue, granularity: PfInputDateGranularity): DateValue;