hys-ui 0.1.0 → 0.2.0

package/dist/types/composables/formContext.d.ts

@@ -1,24 +1,154 @@
-import type { ComputedRef, InjectionKey, Ref } from 'vue';
+import { type ComputedRef, type InjectionKey, type Ref } from "vue";
+import type { RuleType, ValidateMessages } from "async-validator";
+import type { HysFormCol } from "./formLayout";
+export type HysFormPath = string | readonly (string | number)[];
+export type HysFormPaths = string | readonly HysFormPath[];
+export type HysFormTrigger = "blur" | "change";
+export type HysFormStatus = "idle" | "validating" | "success" | "warning" | "error";
+export type HysFormRuleType = RuleType;
+export type HysFormMessages = Partial<ValidateMessages>;
+export interface HysFormValidationContext {
+    path: string;
+    signal: AbortSignal;
+}
+export type HysFormValidateCallback = (valid: boolean, result: HysFormValidationResult) => void | Promise<void>;
+export interface HysFormFieldData {
+    name: HysFormPath;
+    value?: unknown;
+    errors?: string[];
+    warnings?: string[];
+}
 export interface HysFormRule {
+    type?: HysFormRuleType;
     required?: boolean;
-    message?: string;
+    message?: string | ((path?: string) => string);
     min?: number;
     max?: number;
-    pattern?: RegExp;
-    trigger?: 'blur' | 'change' | ('blur' | 'change')[];
-    validator?: (value: unknown, model: Record<string, unknown>) => boolean | string | void | Promise<boolean | string | void>;
+    len?: number;
+    enum?: Array<string | number | boolean | null | undefined>;
+    whitespace?: boolean;
+    pattern?: RegExp | string;
+    transform?: (value: unknown) => unknown;
+    fields?: HysFormRules;
+    defaultField?: HysFormRule | HysFormRule[];
+    trigger?: HysFormTrigger | HysFormTrigger[];
+    level?: "error" | "warning";
+    validator?: (value: unknown, model: Record<string, unknown>, context: HysFormValidationContext) => boolean | string | Error | void | Promise<boolean | string | Error | void>;
+    asyncValidator?: (value: unknown, callback: (error?: string | Error) => void, model: Record<string, unknown>, context: HysFormValidationContext) => void | Promise<void>;
+}
+export interface HysFormRules {
+    [path: string]: HysFormRule | HysFormRule[];
+}
+export interface HysFormValidationResult {
+    valid: boolean;
+    cancelled: boolean;
+    values: Record<string, unknown>;
+    errors: Record<string, string>;
+    warnings: Record<string, string>;
+    errorMessages: Record<string, string[]>;
+    warningMessages: Record<string, string[]>;
+}
+export interface HysFormFieldState {
+    status: HysFormStatus;
+    message: string;
+    warning: string;
+    validating: boolean;
+}
+export interface HysFormField {
+    path: ComputedRef<string>;
+    element: Ref<HTMLElement | undefined>;
+    rules: ComputedRef<HysFormRule[]>;
+    trigger: ComputedRef<HysFormTrigger | HysFormTrigger[]>;
+    dependencies?: ComputedRef<readonly HysFormPath[]>;
+    label: ComputedRef<string | undefined>;
+    validateFirst?: ComputedRef<boolean>;
+    preserve?: ComputedRef<boolean>;
+    validate: (trigger?: HysFormTrigger) => Promise<boolean>;
+    clearValidate: () => void;
+    resetField: () => void;
+    setInitialValue?: (value: unknown) => void;
+    focus: () => void;
 }
 export interface HysFormContext {
+    model: ComputedRef<Record<string, unknown> | undefined>;
+    resetting: Ref<boolean>;
+    suppressAutoBlur?: Ref<boolean>;
     errors: Ref<Record<string, string>>;
-    rules: ComputedRef<Record<string, HysFormRule | HysFormRule[]>>;
-    register: (name: string) => () => void;
-    validateField: (name: string, trigger?: 'blur' | 'change') => Promise<boolean>;
+    warnings: Ref<Record<string, string>>;
+    errorMessages: Ref<Record<string, string[]>>;
+    warningMessages: Ref<Record<string, string[]>>;
+    states: Ref<Record<string, HysFormFieldState>>;
+    rules: ComputedRef<HysFormRules>;
+    getRules: (path: HysFormPath) => HysFormRule[];
+    disabled: ComputedRef<boolean>;
+    size: ComputedRef<"sm" | "md" | "lg">;
+    labelPosition: ComputedRef<"top" | "left" | "right">;
+    labelWidth: ComputedRef<string>;
+    autoLabelWidth: ComputedRef<string>;
+    containerWidth: ComputedRef<number>;
+    columns: ComputedRef<number>;
+    labelAlign: ComputedRef<"left" | "right">;
+    labelWrap: ComputedRef<boolean>;
+    labelSuffix: ComputedRef<string>;
+    colon: ComputedRef<boolean>;
+    labelCol: ComputedRef<HysFormCol | undefined>;
+    wrapperCol: ComputedRef<HysFormCol | undefined>;
+    inlineFeedback: ComputedRef<boolean>;
+    feedbackIcon: ComputedRef<boolean>;
+    optionalMark: ComputedRef<string>;
+    validateFirst: ComputedRef<boolean>;
+    preserve: ComputedRef<boolean>;
+    setLabelWidth: (key: string, width?: number) => void;
+    showLabel: ComputedRef<boolean>;
+    showFeedback: ComputedRef<boolean>;
+    showRequiredMark: ComputedRef<boolean>;
+    requiredMarkPosition: ComputedRef<"left" | "right">;
+    validateTrigger: ComputedRef<HysFormTrigger | HysFormTrigger[]>;
+    validateOnRuleChange: ComputedRef<boolean>;
+    register: (field: HysFormField) => () => void;
+    validateField: (name: HysFormPath, trigger?: HysFormTrigger) => Promise<boolean>;
+    cancelField: (name: HysFormPath) => void;
+    clearValidate: (names?: HysFormPaths) => void;
+    resetFields: (names?: HysFormPaths) => void;
+    setFieldInitialValue: (name: HysFormPath, value: unknown) => void;
 }
 export declare const formKey: InjectionKey<HysFormContext>;
 export interface HysFieldContext {
     id: Ref<string>;
+    label: ComputedRef<string | undefined>;
     error: ComputedRef<string | undefined>;
     errorId: string;
+    describedBy: ComputedRef<string | undefined>;
     required: ComputedRef<boolean>;
+    invalid?: ComputedRef<boolean>;
+    status?: ComputedRef<HysFormStatus>;
+    validate?: (trigger?: HysFormTrigger) => Promise<boolean>;
+    disabled?: ComputedRef<boolean>;
+    size?: ComputedRef<"sm" | "md" | "lg">;
 }
 export declare const fieldKey: InjectionKey<HysFieldContext>;
+/** Integrate a custom control with its nearest FormItem without DOM queries. */
+export declare function useHysFormItemContext(): {
+    id: ComputedRef<string | undefined>;
+    label: ComputedRef<string | undefined>;
+    disabled: ComputedRef<boolean>;
+    size: ComputedRef<"sm" | "md" | "lg">;
+    required: ComputedRef<boolean>;
+    invalid: ComputedRef<boolean>;
+    status: ComputedRef<HysFormStatus>;
+    error: ComputedRef<string | undefined>;
+    describedBy: ComputedRef<string | undefined>;
+    validate: (trigger?: HysFormTrigger) => Promise<boolean>;
+};
+export declare function useHysControlState(props: {
+    disabled?: boolean;
+    size?: "sm" | "md" | "lg";
+}): {
+    disabled: ComputedRef<boolean>;
+    size: ComputedRef<"sm" | "md" | "lg">;
+    label: ComputedRef<string | undefined>;
+};
+export declare function formPath(path: HysFormPath): string;
+export declare function formValue(model: Record<string, unknown> | undefined, path: HysFormPath): unknown;
+export declare function setFormValue(model: Record<string, unknown>, path: HysFormPath, value: unknown): void;
+export declare function focusHysField(control: HTMLElement | null | undefined): void;

package/dist/types/composables/formLayout.d.ts

@@ -0,0 +1,11 @@
+import { type Ref } from "vue";
+export type HysFormBreakpoint = "xs" | "sm" | "md" | "lg" | "xl" | "xxl";
+export type HysFormGridValue = number | Partial<Record<HysFormBreakpoint, number>>;
+export interface HysFormColSize {
+    span?: number;
+    offset?: number;
+}
+export type HysFormCol = HysFormColSize & Partial<Record<HysFormBreakpoint, number | HysFormColSize>>;
+export declare function resolveFormGrid(value: HysFormGridValue | undefined, width: number, fallback?: number): number;
+export declare function resolveFormCol(value: HysFormCol | undefined, width: number): HysFormColSize | undefined;
+export declare function useFormWidth(element: Ref<HTMLElement | undefined>): import("vue").ComputedRef<number>;

package/dist/types/composables/formValidation.d.ts

@@ -0,0 +1,13 @@
+import { type HysFormMessages, type HysFormRule, type HysFormRules, type HysFormValidationContext } from "./formContext";
+export declare function snapshotForm(value: unknown, seen?: WeakMap<object, unknown>): unknown;
+export declare function sameFormValue(a: unknown, b: unknown, seen?: WeakMap<object, object>): boolean;
+export interface HysFormRuleResult {
+    messages: string[];
+    fields: Record<string, string[]>;
+}
+export declare function runFormRules(name: string, value: unknown, rules: HysFormRule[], model: Record<string, unknown>, messages: HysFormMessages | undefined, context: HysFormValidationContext, first?: boolean): HysFormRuleResult | Promise<HysFormRuleResult>;
+/** Resolve a mounted leaf against object/array descriptors declared on parents. */
+export declare function nestedFormRules(path: string, rules: HysFormRules, model?: Record<string, unknown>): {
+    rules: HysFormRule[];
+    value: unknown;
+};

package/dist/types/composables/gantt.d.ts

@@ -0,0 +1,68 @@
+export interface HysGanttScrollOptions {
+    behavior?: ScrollBehavior;
+    block?: ScrollLogicalPosition;
+    horizontal?: boolean;
+}
+export interface HysGanttDependencyChange {
+    sourceId: string | number;
+    targetId: string | number;
+    type: "add" | "remove";
+}
+export type HysGanttDependencyReason = "missing" | "disabled" | "self" | "duplicate" | "cycle" | "rejected" | "busy";
+export type HysGanttHistoryType = "move" | "resize-start" | "resize-end" | "nudge" | "dependency-add" | "dependency-remove" | "dependency-move";
+export interface HysGanttHistoryEntry {
+    type: HysGanttHistoryType;
+    label: string;
+    taskIds: Array<string | number>;
+}
+export interface HysGanttHistoryState {
+    canUndo: boolean;
+    canRedo: boolean;
+    undoCount: number;
+    redoCount: number;
+    undoLabel: string;
+    redoLabel: string;
+    pending: boolean;
+}
+export interface HysGanttHistoryInvalid {
+    action: "undo" | "redo";
+    reason: "disabled" | "busy" | "missing" | "stale" | "rejected";
+}
+export type HysGanttConflictType = "dependency-order" | "invalid-date" | "missing-dependency" | "dependency-cycle";
+export interface HysGanttConflict {
+    id: string;
+    type: HysGanttConflictType;
+    taskId: string | number;
+    taskTitle: string;
+    sourceId?: string | number;
+    sourceTitle?: string;
+    message: string;
+    expectedStart?: string;
+    days?: number;
+}
+export interface HysGanttDependencyMove {
+    sourceId: string | number;
+    previousTargetId: string | number;
+    targetId: string | number;
+    type: "move";
+}
+export type HysGanttDependencyInvalid = (HysGanttDependencyChange | HysGanttDependencyMove) & {
+    reason: HysGanttDependencyReason;
+};
+export interface HysGanttInstance {
+    element: HTMLElement | undefined;
+    viewport: HTMLElement | null;
+    scrollToTask: (id: string | number, options?: HysGanttScrollOptions) => Promise<boolean>;
+    scrollToTop: (options?: Pick<HysGanttScrollOptions, "behavior">) => void;
+    addDependency: (sourceId: string | number, targetId: string | number) => Promise<boolean>;
+    removeDependency: (sourceId: string | number, targetId: string | number) => Promise<boolean>;
+    cancelDependency: () => void;
+    moveDependency: (sourceId: string | number, previousTargetId: string | number, targetId: string | number) => Promise<boolean>;
+    canUndo: boolean;
+    canRedo: boolean;
+    historyState: HysGanttHistoryState;
+    undo: () => Promise<boolean>;
+    redo: () => Promise<boolean>;
+    clearHistory: () => void;
+    conflicts: readonly HysGanttConflict[];
+}

package/dist/types/composables/ganttConflicts.d.ts

@@ -0,0 +1,30 @@
+import type { HysGanttConflict } from "./gantt";
+type Id = string | number;
+export interface GanttScheduleTask {
+    id: Id;
+    title: string;
+    start: string;
+    end: string;
+    dependencies?: readonly Id[];
+}
+interface Task extends GanttScheduleTask {
+    s: number | null;
+    e: number | null;
+}
+interface Edge {
+    sourceId: Id;
+    targetId: Id;
+    id: string;
+}
+export declare function parseGanttDay(value: string): number | null;
+export declare const ganttEdgeKey: (source: Id, target: Id) => string;
+export declare function analyzeGanttSchedule(items: readonly GanttScheduleTask[]): {
+    conflicts: HysGanttConflict[];
+    byTask: Map<Id, HysGanttConflict[]>;
+    byEdge: Map<string, HysGanttConflict>;
+    tasks: Map<Id, Task>;
+    incident: Map<Id, Edge[]>;
+    cyclic: Set<string>;
+};
+export declare function previewGanttConflicts(analysis: ReturnType<typeof analyzeGanttSchedule>, id: Id, start: number, end: number): HysGanttConflict[];
+export {};

package/dist/types/composables/numberInput.d.ts

@@ -0,0 +1,45 @@
+export type HysNumberInputValue = number | string | null;
+export interface HysNumberInputFormatInfo {
+    userTyping: boolean;
+    input: string;
+}
+export interface HysNumberInputStepInfo {
+    offset: number | string;
+    type: "up" | "down";
+    source: "button" | "keyboard" | "wheel" | "repeat" | "method";
+}
+export interface HysNumberInputInvalidInfo {
+    input: string;
+    reason: "parse" | "validator" | "range";
+}
+export interface HysNumberInputInstance {
+    input: HTMLInputElement | undefined;
+    focus: (options?: FocusOptions) => void;
+    blur: () => void;
+    select: () => void;
+    clear: () => void;
+    commit: () => boolean;
+    increase: (multiplier?: number) => void;
+    decrease: (multiplier?: number) => void;
+}
+export interface Decimal {
+    units: bigint;
+    scale: number;
+}
+export declare function decimal(value: unknown): Decimal | undefined;
+export declare function decimalCompare(a: Decimal, b: Decimal): 0 | 1 | -1;
+export declare function decimalAdd(a: Decimal, b: Decimal, multiplier?: number): {
+    units: bigint;
+    scale: number;
+};
+export declare function decimalRound(value: Decimal, precision: number): Decimal;
+export declare function decimalText(value: Decimal, padTo?: number): string;
+export interface NumberConstraints {
+    step: Decimal;
+    base: Decimal;
+    min?: Decimal;
+    max?: Decimal;
+    precision?: number;
+    strict: boolean;
+}
+export declare function normalizeDecimal(value: Decimal, options: NumberConstraints): Decimal | undefined;

package/dist/types/composables/rating.d.ts

@@ -0,0 +1,18 @@
+import type { Component } from "vue";
+export type HysRatingIcon = Component | string;
+export type HysRatingLevels<T> = readonly T[] | Record<number, T | {
+    value: T;
+    excluded?: boolean;
+}>;
+export interface HysRatingInstance {
+    element: HTMLElement | undefined;
+    value: number;
+    hoverValue: number | null;
+    focus: (options?: FocusOptions) => void;
+    blur: () => void;
+    setValue: (value: number) => Promise<boolean>;
+    clear: () => Promise<boolean>;
+    setCurrentValue: (value: number) => void;
+    resetCurrentValue: () => void;
+}
+export declare function ratingLevel<T>(levels: HysRatingLevels<T> | undefined, value: number, low: number, high: number, fallback: T): T;

package/dist/types/composables/segmented.d.ts

@@ -0,0 +1,15 @@
+import type { Component, CSSProperties } from "vue";
+import type { HysChoiceOption, HysChoiceValue } from "./choice";
+export interface HysSegmentedOption<T extends HysChoiceValue = HysChoiceValue> extends HysChoiceOption<T> {
+    icon?: Component | string;
+    title?: string;
+    className?: string;
+    style?: CSSProperties;
+}
+export interface HysSegmentedInstance {
+    element: HTMLElement | undefined;
+    value: HysChoiceValue | null;
+    focus: (value?: HysChoiceValue) => void;
+    blur: () => void;
+    select: (value: HysChoiceValue) => Promise<boolean>;
+}

package/dist/types/composables/selectOptions.d.ts

@@ -0,0 +1,44 @@
+export type HysSelectValue = string | number | boolean | Record<string, unknown>;
+export type HysSelectModelValue = HysSelectValue | HysSelectValue[] | null;
+export interface HysSelectOption {
+    label: string;
+    value: HysSelectValue;
+    disabled?: boolean;
+    [key: string]: unknown;
+}
+export interface HysSelectGroup {
+    label: string;
+    options: HysSelectOption[];
+    disabled?: boolean;
+    [key: string]: unknown;
+}
+export type HysSelectDataOption = HysSelectOption | HysSelectGroup | Record<string, unknown>;
+export interface HysSelectFieldNames {
+    label?: string;
+    value?: string;
+    options?: string;
+    disabled?: string;
+}
+export interface HysSelectSearchContext {
+    signal: AbortSignal;
+}
+export interface HysSelectInstance {
+    focus: () => void;
+    blur: () => void;
+    open: () => Promise<void>;
+    close: () => void;
+    scrollTo: (value: HysSelectValue) => void;
+    retry: () => void;
+    selected: HysSelectOption[];
+    query: string;
+    isOpen: boolean;
+}
+export interface HysSelectRow {
+    key: string;
+    option?: HysSelectOption;
+    group?: string;
+    index: number;
+    created?: boolean;
+}
+export declare function selectKeyFactory(valueKey: () => string): (value: HysSelectValue) => string;
+export declare function normalizeSelectOptions(options: readonly HysSelectDataOption[], names: HysSelectFieldNames, keyOf: (value: HysSelectValue) => string): HysSelectRow[];

package/dist/types/composables/slider.d.ts

@@ -0,0 +1,21 @@
+import type { CSSProperties } from "vue";
+export type HysSliderValue = number | [number, number];
+export type HysSliderStep = number | "mark" | null;
+export type HysSliderMarks = Record<number, string | {
+    label: string;
+    style?: CSSProperties;
+}>;
+export interface HysSliderDragInfo {
+    index: number;
+    track: boolean;
+    cancelled: boolean;
+}
+export interface HysSliderInstance {
+    element: HTMLElement | undefined;
+    dragging: boolean;
+    values: number[];
+    focus: (index?: number) => void;
+    blur: () => void;
+    setValue: (value: HysSliderValue) => void;
+    cancel: () => void;
+}