@kazee-ds/vue 0.6.0 → 0.7.0

package/dist/types/temporal-context.d.ts

@@ -0,0 +1,32 @@
+import { type InjectionKey, type Ref } from 'vue';
+import type { TemporalKind } from './temporal-model.js';
+import type { TemporalOptions, TemporalValue } from './temporal-types.js';
+export interface TemporalContext {
+    options: TemporalOptions;
+    kind: TemporalKind;
+    range: boolean;
+    draft: Ref<TemporalValue | null>;
+    error: Readonly<Ref<string | null>>;
+    text: Readonly<Ref<string>>;
+    isDialog: Readonly<Ref<boolean>>;
+    id: string;
+    invalid: Readonly<Ref<boolean>>;
+    describedBy: Readonly<Ref<string | undefined>>;
+    edit: (value: TemporalValue | null, part?: string) => void;
+    inputError: (part: string, error: string | null) => void;
+    apply: () => void;
+    cancel: () => void;
+    clear: () => void;
+}
+export declare const temporalKey: InjectionKey<TemporalContext>;
+export declare function useTemporal(): TemporalContext;
+export declare function temporalLabels(locale?: string): {
+    apply: string;
+    cancel: string;
+    clear: string;
+    today: string;
+    now: string;
+    start: string;
+    end: string;
+    choose: string;
+};

package/dist/types/temporal-model.d.ts

@@ -0,0 +1,44 @@
+export type TemporalKind = 'date' | 'time' | 'datetime';
+export interface TemporalRange {
+    start: string;
+    end: string;
+}
+export type TemporalError = 'invalid' | 'required' | 'incomplete' | 'order' | 'bounds' | 'unavailable' | 'step';
+export interface TemporalConstraints {
+    kind: TemporalKind;
+    minDate?: string;
+    maxDate?: string;
+    minTime?: string;
+    maxTime?: string;
+    minDateTime?: string;
+    maxDateTime?: string;
+    isDateUnavailable?: (date: string) => boolean;
+    isTimeUnavailable?: (time: string) => boolean;
+    isRequired?: boolean;
+    hourStep?: number;
+    minuteStep?: number;
+    secondStep?: number;
+    granularity?: 'hour' | 'minute' | 'second';
+    timeZone?: string;
+    disambiguation?: 'compatible' | 'earlier' | 'later' | 'reject';
+}
+/** Wall time is resolved explicitly; DST gaps/overlaps reject by default. */
+export declare function toZonedValue(value: string, timeZone?: string, disambiguation?: TemporalConstraints['disambiguation']): string;
+export declare function toLocalValue(value: string, timeZone?: string, seconds?: boolean): string;
+export declare function temporalError(value: string | null, options: TemporalConstraints): TemporalError | null;
+export declare function temporalRangeError(value: TemporalRange | null, options: TemporalConstraints): TemporalError | null;
+/** Project instant boundaries into the selected display zone for disabled calendar/time options. */
+export declare function temporalDisplayBounds(options: TemporalConstraints, selectedDate?: string): {
+    minDate: string | undefined;
+    maxDate: string | undefined;
+    minTime: string | undefined;
+    maxTime: string | undefined;
+};
+/** Minute-granularity list; seconds are edited with TimeField/TimeClock to avoid 86k DOM options. */
+export declare function timeChoices(options: TemporalConstraints): string[];
+/** User edits zero units hidden by the configured field granularity. */
+export declare function normalizeTime(value: string, granularity?: TemporalConstraints['granularity']): string;
+export declare function normalizeWallDateTime(value: string, granularity?: TemporalConstraints['granularity']): string;
+/** Keep the selected unit and choose the nearest complete valid time for the other units. */
+export declare function resolveTimeUnit(value: string, part: 'hour' | 'minute' | 'second', selected: number, options: TemporalConstraints): string | null;
+export declare function temporalMessages(locale?: string): Record<TemporalError, string>;

package/dist/types/temporal-parts.d.ts

@@ -0,0 +1,53 @@
+import { type PropType } from 'vue';
+export declare const TemporalPickerField: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    part: {
+        type: PropType<"start" | "end">;
+        default: string;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    part: {
+        type: PropType<"start" | "end">;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    part: "start" | "end";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const TemporalPickerCalendar: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const TemporalPickerTime: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    part: {
+        type: PropType<"start" | "end">;
+        default: string;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    part: {
+        type: PropType<"start" | "end">;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    part: "start" | "end";
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const TemporalPickerValue: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const TemporalPickerTrigger: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const TemporalPickerContent: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const TemporalPickerPopover: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export declare const TemporalPickerApplyButton: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, TemporalPickerCancelButton: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>, TemporalPickerClearButton: import("vue").DefineComponent<{}, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/dist/types/temporal-types.d.ts

@@ -0,0 +1,56 @@
+import type { TemporalConstraints, TemporalKind, TemporalRange } from './temporal-model.js';
+import type { HTMLAttributes } from 'vue';
+export type TemporalNativeAttributes = Pick<HTMLAttributes, 'class' | 'style' | 'id' | 'role' | 'aria-label' | 'aria-labelledby' | 'aria-describedby'>;
+export type TemporalValue = string | TemporalRange;
+export interface TemporalPreset<T = TemporalValue> {
+    id: string;
+    label: string;
+    value: T | null;
+}
+export interface TemporalOptions extends Omit<TemporalConstraints, 'kind'> {
+    label: string;
+    locale?: string;
+    dir?: 'ltr' | 'rtl';
+    size?: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    hourCycle?: 12 | 24;
+    display?: 'inline' | 'popover' | 'dialog' | 'auto';
+    commitMode?: 'apply' | 'immediate';
+    disabled?: boolean;
+    readonly?: boolean;
+    required?: boolean;
+    invalid?: boolean;
+    isDisabled?: boolean;
+    isReadOnly?: boolean;
+    isRequired?: boolean;
+    isInvalid?: boolean;
+    hideLabel?: boolean;
+    name?: string;
+    description?: string;
+    errorMessage?: string;
+    open?: boolean;
+    defaultOpen?: boolean;
+    visibleMonths?: 1 | 2;
+    weekStartsOn?: 0 | 1;
+    referenceDate?: string;
+    timePresentation?: 'list' | 'clock';
+    showInputs?: boolean;
+    showActions?: boolean;
+    formatValue?: (value: TemporalValue, locale: string) => string;
+    classNames?: Partial<Record<'root' | 'label' | 'trigger' | 'value' | 'panel' | 'content' | 'field' | 'calendar' | 'time' | 'footer' | 'applyButton' | 'cancelButton' | 'clearButton' | 'preset' | 'description' | 'error' | 'input' | 'segment', string>>;
+}
+export interface TemporalPickerProps<T = TemporalValue> extends TemporalOptions, TemporalNativeAttributes {
+    modelValue?: T | null;
+    defaultValue?: T | null;
+    presets?: TemporalPreset<T>[];
+    'onUpdate:modelValue'?: (value: T | null) => void;
+    onChange?: (value: T | null) => void;
+    onApply?: (value: T | null) => void;
+    'onUpdate:open'?: (open: boolean) => void;
+    onError?: (error: string | null) => void;
+}
+export interface TemporalFieldOptions extends TemporalOptions {
+    formValidation?: boolean;
+    modelValue?: string | null;
+    defaultValue?: string | null;
+    kind?: TemporalKind;
+}

package/dist/types/toggle-group-model.d.ts

@@ -4,6 +4,6 @@ export interface ToggleGroupItem {
     isDisabled?: boolean;
 }
 export type ToggleGroupMode = 'single' | 'multiple';
-export type ToggleGroupVariant = 'outline' | 'ghost';
+export type ToggleGroupVariant = 'outline' | 'ghost' | 'chip';
 /** Normalize IDs without discarding existing disabled selections. */
 export declare function toggleIds(value: unknown, items: ToggleGroupItem[], multiple: boolean): string[];

package/dist/types/types.d.ts

@@ -1,10 +1,10 @@
 export type ButtonVariant = 'primary' | 'secondary' | 'danger' | 'outline' | 'tertiary' | 'ghost' | 'danger-soft' | 'ai';
-export type ButtonSize = 'sm' | 'md' | 'lg';
-export type InputSize = 'sm' | 'md' | 'lg';
-export type SelectSize = 'sm' | 'md' | 'lg';
-export type SelectVariant = 'primary' | 'secondary' | 'outline';
+export type ButtonSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type InputSize = 'xs' | 'sm' | 'dense' | 'md' | 'lg' | 'xl';
+export type SelectSize = 'xs' | 'sm' | 'dense' | 'md' | 'lg' | 'xl';
+export type SelectVariant = 'primary' | 'secondary' | 'outline' | 'flat';
 export type InputType = 'text' | 'email' | 'password' | 'search' | 'tel' | 'url';
-export type InputVariant = 'primary' | 'secondary';
+export type InputVariant = 'primary' | 'secondary' | 'flat' | 'sunken';
 export type InputMode = 'none' | 'text' | 'tel' | 'url' | 'email' | 'numeric' | 'decimal' | 'search';
 export type InputEnterKeyHint = 'enter' | 'done' | 'go' | 'next' | 'previous' | 'search' | 'send';
 export type { SelectOption } from './selection-options.js';
@@ -32,7 +32,7 @@ export interface FieldSlotProps {
     invalid: boolean;
     errorMessage: string | undefined;
 }
-export type BadgeTone = 'neutral' | 'info' | 'success' | 'warning' | 'danger';
+export type BadgeTone = import('./visual.js').Tone;
 export interface TabItem {
     id: string;
     label: string;

package/dist/types/visual.d.ts

@@ -0,0 +1,6 @@
+export type Tone = 'neutral' | 'primary' | 'info' | 'success' | 'warning' | 'danger';
+export type ComponentSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type IndicatorPlacement = 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+export type AvatarVariant = 'default' | 'soft';
+export type BadgeVariant = 'default' | 'solid' | 'soft' | 'outline' | 'ghost' | 'link';
+export type ImageLoadingStatus = 'idle' | 'loading' | 'loaded' | 'error';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kazee-ds/vue",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "type": "module",
   "exports": {
     ".": {