hys-ui 0.1.1 → 0.3.0

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/menu.d.ts

@@ -0,0 +1,183 @@
+import type { HysPopupMotionProps } from "../motion/popup";
+import { type Component, type CSSProperties, type VNodeChild } from "vue";
+import type { Placement } from "./useFloating";
+export type HysMenuKey = string | number;
+export type HysContextMenuTrigger = "contextmenu" | "click" | "hover" | "focus";
+export interface HysContextMenuItem {
+    label: string;
+    value?: HysMenuKey;
+    type?: "item" | "divider" | "group" | "checkbox" | "radio";
+    children?: readonly HysContextMenuItem[];
+    disabled?: boolean;
+    hidden?: boolean;
+    danger?: boolean;
+    icon?: Component;
+    description?: string;
+    shortcut?: string;
+    href?: string;
+    target?: string;
+    rel?: string;
+    checked?: boolean;
+    radioGroup?: HysMenuKey;
+    closeOnSelect?: boolean;
+}
+export interface HysMenuFieldNames {
+    value: string;
+    label: string;
+    children: string;
+    disabled: string;
+    hidden: string;
+    type: string;
+    icon: string;
+    description: string;
+    shortcut: string;
+    href: string;
+    target: string;
+    rel: string;
+    danger: string;
+    checked: string;
+    radioGroup: string;
+    closeOnSelect: string;
+}
+export interface HysMenuSelectInfo<N extends object = HysContextMenuItem> {
+    item: N;
+    path: readonly N[];
+    keys: readonly HysMenuKey[];
+    event: MouseEvent | KeyboardEvent | undefined;
+    checked?: boolean;
+    checkedKeys: readonly HysMenuKey[];
+    selectedKeys: readonly HysMenuKey[];
+}
+export interface HysMenuShowOptions {
+    x?: number;
+    y?: number;
+    focus?: boolean;
+}
+export interface HysContextMenuProps<N extends object = HysContextMenuItem> extends HysPopupMotionProps {
+    items: readonly N[];
+    fieldNames?: Partial<HysMenuFieldNames>;
+    disabled?: boolean;
+    loading?: boolean;
+    size?: "sm" | "md" | "lg";
+    trigger?: HysContextMenuTrigger | readonly HysContextMenuTrigger[];
+    open?: boolean;
+    defaultOpen?: boolean;
+    openPath?: readonly HysMenuKey[];
+    defaultOpenPath?: readonly HysMenuKey[];
+    checkedKeys?: readonly HysMenuKey[];
+    defaultCheckedKeys?: readonly HysMenuKey[];
+    selectedKeys?: readonly HysMenuKey[];
+    defaultSelectedKeys?: readonly HysMenuKey[];
+    selectable?: boolean;
+    multiple?: boolean;
+    hideOnClick?: boolean;
+    autofocus?: boolean;
+    loopNavigation?: boolean;
+    showDelay?: number;
+    hideDelay?: number;
+    submenuDelay?: number;
+    submenuTrigger?: "hover" | "click";
+    placement?: Placement;
+    appendTo?: string | HTMLElement | false;
+    width?: string | number;
+    minWidth?: number;
+    maxWidth?: number;
+    maxHeight?: number;
+    arrow?: boolean;
+    popupClass?: string;
+    popupStyle?: CSSProperties;
+    direction?: "ltr" | "rtl";
+    ariaLabel?: string;
+    emptyText?: string;
+    loadingText?: string;
+    backText?: string;
+}
+export interface HysContextMenuInstance<N extends object = HysContextMenuItem> {
+    readonly element: HTMLElement | undefined;
+    readonly open: boolean;
+    readonly checkedKeys: HysMenuKey[];
+    readonly selectedKeys: HysMenuKey[];
+    readonly openPath: HysMenuKey[];
+    focus: () => void;
+    blur: () => void;
+    show: (event?: MouseEvent | KeyboardEvent | HysMenuShowOptions) => Promise<boolean>;
+    showAt: (x: number, y: number, focus?: boolean) => Promise<boolean>;
+    hide: (restoreFocus?: boolean) => Promise<boolean>;
+    handleOpen: () => Promise<boolean>;
+    handleClose: () => Promise<boolean>;
+    toggle: () => Promise<boolean>;
+    focusItem: (key: HysMenuKey) => Promise<boolean>;
+    openSubmenu: (key: HysMenuKey) => Promise<boolean>;
+    closeSubmenus: () => Promise<boolean>;
+    setCheckedKeys: (keys: readonly HysMenuKey[]) => Promise<boolean>;
+    setSelectedKeys: (keys: readonly HysMenuKey[]) => Promise<boolean>;
+    getItems: () => N[];
+}
+export interface HysMenuItemContext<N extends object = HysContextMenuItem> {
+    item: N;
+    value: HysMenuKey | undefined;
+    label: string;
+    path: readonly N[];
+    keys: readonly HysMenuKey[];
+    level: number;
+    disabled: boolean;
+    checked: boolean;
+    selected: boolean;
+    expanded: boolean;
+    submenu: boolean;
+}
+export interface HysContextMenuSlots<N extends object = HysContextMenuItem> {
+    default?: (scope: {
+        open: boolean;
+        show: HysContextMenuInstance<N>["show"];
+        hide: HysContextMenuInstance<N>["hide"];
+        toggle: HysContextMenuInstance<N>["toggle"];
+        attrs: Record<string, unknown>;
+    }) => VNodeChild;
+    item?: (scope: HysMenuItemContext<N>) => VNodeChild;
+    icon?: (scope: HysMenuItemContext<N>) => VNodeChild;
+    link?: (scope: HysMenuItemContext<N> & {
+        attrs: Record<string, unknown>;
+    }) => VNodeChild;
+    header?: (scope: {
+        close: () => Promise<boolean>;
+    }) => VNodeChild;
+    footer?: (scope: {
+        close: () => Promise<boolean>;
+    }) => VNodeChild;
+    empty?: () => VNodeChild;
+    loading?: () => VNodeChild;
+}
+export interface MenuRow<N extends object> {
+    id: string;
+    raw: N;
+    key?: HysMenuKey;
+    label: string;
+    type: NonNullable<HysContextMenuItem["type"]>;
+    disabled: boolean;
+    danger: boolean;
+    icon?: Component;
+    description: string;
+    shortcut: string;
+    href?: string;
+    target?: string;
+    rel?: string;
+    radioGroup?: HysMenuKey;
+    checked: boolean;
+    closeOnSelect?: boolean;
+    children: MenuRow<N>[];
+    parents: MenuRow<N>[];
+    path: N[];
+    keys: HysMenuKey[];
+    level: number;
+}
+export declare const menuToken: (key: HysMenuKey) => string;
+export declare function menuKeys(keys: readonly HysMenuKey[] | undefined): HysMenuKey[];
+export declare const menuKeysEqual: (a: readonly HysMenuKey[], b: readonly HysMenuKey[]) => boolean;
+export declare function menuField(item: object, path: string): unknown;
+export declare const menuSafeRel: (target?: string, rel?: string) => string | undefined;
+export declare function menuRows<N extends object>(items: readonly N[], fields?: Partial<HysMenuFieldNames>): {
+    roots: MenuRow<N>[];
+    all: MenuRow<N>[];
+    byKey: Map<string, MenuRow<N>>;
+};

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

@@ -0,0 +1,183 @@
+import type { Component, CSSProperties, TransitionProps, VNodeChild } from "vue";
+import type { HysButtonProps, HysButtonVariant } from "../components/HysButton/HysButton.vue";
+export type HysModalCloseReason = "mask" | "escape" | "button" | "cancel" | "confirm" | "api";
+export type HysModalType = "default" | "confirm" | "info" | "success" | "warning" | "error";
+export type HysModalInitialFocus = "auto" | "dialog" | "confirm" | "cancel" | false | string | InstanceType<typeof HTMLElement>;
+export type HysModalSizeName = "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "full";
+export declare const modalWidths: {
+    readonly xs: 360;
+    readonly sm: 440;
+    readonly md: 560;
+    readonly lg: 720;
+    readonly xl: 960;
+    readonly "2xl": 1200;
+    readonly full: "100%";
+};
+export declare const modalWidth: (props: HysModalProps) => string | number;
+export type HysModalSectionSize = "sm" | "md" | "lg";
+export type HysModalDragEffect = "lift" | "outline" | "glow" | "shadow" | "ghost" | "none";
+export interface HysModalActionContext {
+    reason: HysModalCloseReason;
+    event?: Event;
+    signal: AbortSignal;
+}
+export interface HysModalPosition {
+    x: number;
+    y: number;
+}
+export interface HysModalSize {
+    width: number;
+    height: number;
+}
+export type HysModalBeforeClose = {
+    invoke(reason: HysModalCloseReason, context: HysModalActionContext): boolean | void | Promise<boolean | void>;
+}["invoke"];
+export interface HysModalProps {
+    open?: boolean;
+    modelValue?: boolean;
+    defaultOpen?: boolean;
+    title?: string;
+    description?: string;
+    type?: HysModalType;
+    showIcon?: boolean;
+    /** Background opacity from 0 to 1; does not fade text or controls. */
+    opacity?: number;
+    /** Mask opacity from 0 to 1; omitted keeps the default mask style. */
+    maskOpacity?: number;
+    icon?: Component;
+    width?: string | number;
+    height?: string | number;
+    maxHeight?: string | number;
+    minWidth?: number;
+    minHeight?: number;
+    maxWidth?: number;
+    size?: HysModalSizeName;
+    centered?: boolean;
+    top?: string | number;
+    center?: boolean;
+    fullscreen?: boolean;
+    defaultFullscreen?: boolean;
+    showFullscreen?: boolean;
+    closeOnMask?: boolean;
+    closeOnEscape?: boolean;
+    showClose?: boolean;
+    destroyOnClose?: boolean;
+    forceRender?: boolean;
+    modal?: boolean;
+    modalPenetrable?: boolean;
+    appendTo?: string | InstanceType<typeof HTMLElement> | false;
+    lockScroll?: boolean;
+    trapFocus?: boolean;
+    restoreFocus?: boolean;
+    initialFocus?: HysModalInitialFocus;
+    openDelay?: number;
+    closeDelay?: number;
+    transition?: string | TransitionProps | false;
+    transitionDuration?: number;
+    zIndex?: number;
+    headerClass?: string;
+    headerSize?: HysModalSectionSize;
+    footerSize?: HysModalSectionSize;
+    /** Minimum height. Content may expand the region to avoid clipping. */
+    headerHeight?: string | number;
+    footerHeight?: string | number;
+    titleFontSize?: string | number;
+    bodyClass?: string;
+    footerClass?: string;
+    overlayClass?: string;
+    modalClass?: string;
+    headerStyle?: CSSProperties;
+    bodyStyle?: CSSProperties;
+    footerStyle?: CSSProperties;
+    maskStyle?: CSSProperties;
+    modalStyle?: CSSProperties;
+    ariaLabel?: string;
+    ariaLabelledby?: string;
+    ariaDescribedby?: string;
+    role?: "dialog" | "alertdialog";
+    headerAriaLevel?: number;
+    closeText?: string;
+    fullscreenText?: string;
+    restoreText?: string;
+    footer?: boolean;
+    footerAlign?: "start" | "center" | "end";
+    showCancel?: boolean;
+    okText?: string;
+    cancelText?: string;
+    okVariant?: HysButtonVariant;
+    okButtonProps?: HysButtonProps;
+    cancelButtonProps?: HysButtonProps;
+    confirmLoading?: boolean;
+    confirmDisabled?: boolean;
+    cancelDisabled?: boolean;
+    closeWhileConfirming?: boolean;
+    loading?: boolean;
+    loadingText?: string;
+    showError?: boolean;
+    errorText?: string | ((error: unknown, action: "confirm" | "close") => string);
+    confirmOnCtrlEnter?: boolean;
+    closeOnConfirm?: boolean;
+    beforeClose?(reason: HysModalCloseReason, context: HysModalActionContext): boolean | void | Promise<boolean | void>;
+    beforeConfirm?: (context: HysModalActionContext) => boolean | void | Promise<boolean | void>;
+    draggable?: boolean;
+    dragHandlePosition?: "center" | "left" | "right" | "both";
+    dragMode?: "live" | "preview";
+    /** Pointer movement in pixels before a header press becomes a drag. */
+    dragThreshold?: number;
+    /** Lightweight gesture feedback, activated only at drag start/end. */
+    dragEffect?: HysModalDragEffect;
+    overflow?: boolean;
+    /** Keep the move handle reachable even when the panel may overflow. */
+    keepHandleVisible?: boolean;
+    resizable?: boolean;
+    resetPositionOnClose?: boolean;
+    resetSizeOnClose?: boolean;
+    /** Retained legacy setting; position in a modal is controlled by centered/top. */
+    placement?: "left" | "right" | "top" | "bottom";
+}
+export interface HysModalSlotContext {
+    close: (reason?: HysModalCloseReason | Event) => Promise<boolean>;
+    cancel: (event?: Event) => Promise<boolean>;
+    confirm: (event?: Event) => Promise<boolean>;
+    closing: boolean;
+    confirming: boolean;
+    busy: boolean;
+    error: string;
+    titleId: string;
+    descriptionId: string;
+    fullscreen: boolean;
+    toggleFullscreen: () => Promise<boolean>;
+}
+export interface HysModalSlots {
+    default?: (context: HysModalSlotContext) => VNodeChild;
+    header?: (context: HysModalSlotContext) => VNodeChild;
+    footer?: (context: HysModalSlotContext) => VNodeChild;
+    icon?: (context: HysModalSlotContext) => VNodeChild;
+    loading?: (context: HysModalSlotContext) => VNodeChild;
+    "close-icon"?: (context: HysModalSlotContext) => VNodeChild;
+    "fullscreen-icon"?: (context: HysModalSlotContext) => VNodeChild;
+}
+export interface HysModalInstance {
+    readonly element: HTMLElement | undefined;
+    readonly open: boolean;
+    readonly closing: boolean;
+    readonly confirming: boolean;
+    readonly fullscreen: boolean;
+    readonly position: HysModalPosition;
+    readonly dimensions: HysModalSize | undefined;
+    show: () => Promise<boolean>;
+    hide: () => Promise<boolean>;
+    close: (reason?: HysModalCloseReason) => Promise<boolean>;
+    handleOpen: () => Promise<boolean>;
+    handleClose: () => Promise<boolean>;
+    confirm: (event?: Event) => Promise<boolean>;
+    cancel: (event?: Event) => Promise<boolean>;
+    focus: () => void;
+    toggleFullscreen: () => Promise<boolean>;
+    setFullscreen: (value: boolean) => Promise<boolean>;
+    resetPosition: () => void;
+    resetSize: () => void;
+    setPosition: (position: HysModalPosition) => void;
+    setSize: (size: HysModalSize) => void;
+}
+export declare const modalLength: (value: string | number | undefined) => string | undefined;

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/overlayManager.d.ts

@@ -1,7 +1,11 @@
-export type OverlayKind = 'floating' | 'dialog';
-export declare const overlayCount: import("vue").Ref<number, number>;
-export declare function registerOverlay(kind: OverlayKind, dismiss: () => void): {
+/** Shared, deterministic overlay stack. Only the topmost layer responds to Escape. */
+import { type InjectionKey, type Ref } from "vue";
+export declare const overlayOwnerKey: InjectionKey<Readonly<Ref<boolean>>>;
+export type OverlayKind = "floating" | "dialog";
+export declare const overlayCount: Ref<number, number>;
+export declare function registerOverlay(kind: OverlayKind, dismiss: () => void, base?: () => number | undefined): {
     id: symbol;
+    zIndex: import("vue").ComputedRef<number>;
     isTop: () => boolean;
     unregister: () => void;
 };

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

@@ -0,0 +1,83 @@
+import type { CSSProperties, VNodeChild } from "vue";
+import type { HysPopupMotionProps } from "../motion/popup";
+import type { Placement } from "./useFloating";
+export type HysPopupPlacement = Placement;
+export type HysPopupTrigger = "hover" | "focus" | "click" | "contextmenu" | "manual";
+export interface HysPopupVirtualReference {
+    getBoundingClientRect: () => DOMRect;
+    contextElement?: HTMLElement;
+}
+export type HysPopupReference = HTMLElement | HysPopupVirtualReference;
+export interface HysPopupSurfaceProps extends HysPopupMotionProps {
+    open?: boolean;
+    modelValue?: boolean;
+    defaultOpen?: boolean;
+    disabled?: boolean;
+    trigger?: HysPopupTrigger | readonly HysPopupTrigger[];
+    triggerKeys?: readonly string[];
+    triggerTabindex?: number;
+    placement?: HysPopupPlacement;
+    offset?: number;
+    autoAdjustOverflow?: boolean;
+    showDelay?: number;
+    hideDelay?: number;
+    autoClose?: number;
+    enterable?: boolean;
+    closeOnEscape?: boolean;
+    closeOnOutside?: boolean;
+    destroyOnHide?: boolean;
+    forceRender?: boolean;
+    appendTo?: string | HTMLElement | false;
+    reference?: HysPopupReference | (() => HysPopupReference | undefined);
+    width?: string | number;
+    maxWidth?: string | number;
+    maxHeight?: string | number;
+    showArrow?: boolean;
+    arrowOffset?: number;
+    effect?: "light" | "dark";
+    color?: string;
+    textColor?: string;
+    overlayClass?: string;
+    overlayStyle?: CSSProperties;
+    contentClass?: string;
+    contentStyle?: CSSProperties;
+    zIndex?: number;
+    ariaLabel?: string;
+}
+export interface HysTooltipProps extends HysPopupSurfaceProps {
+    text?: string;
+}
+export interface HysPopoverProps extends HysPopupSurfaceProps {
+    title?: string;
+    content?: string;
+}
+export interface HysPopupSurfaceContext {
+    open: boolean;
+    show: () => Promise<boolean>;
+    close: () => Promise<boolean>;
+    toggle: () => Promise<boolean>;
+    updatePosition: () => void;
+}
+export interface HysTooltipSlots {
+    default?: (scope: HysPopupSurfaceContext) => VNodeChild;
+    content?: (scope: HysPopupSurfaceContext) => VNodeChild;
+}
+export interface HysPopoverSlots {
+    trigger?: (scope: HysPopupSurfaceContext) => VNodeChild;
+    default?: (scope: HysPopupSurfaceContext) => VNodeChild;
+    title?: (scope: HysPopupSurfaceContext) => VNodeChild;
+}
+export interface HysPopupSurfaceInstance {
+    readonly element: HTMLElement | undefined;
+    readonly referenceElement: HTMLElement | undefined;
+    readonly open: boolean;
+    readonly placement: HysPopupPlacement;
+    show: () => Promise<boolean>;
+    hide: () => Promise<boolean>;
+    close: () => Promise<boolean>;
+    toggle: () => Promise<boolean>;
+    updatePosition: () => void;
+    focus: () => void;
+}
+export type HysTooltipInstance = HysPopupSurfaceInstance;
+export type HysPopoverInstance = HysPopupSurfaceInstance;