hys-ui 0.2.0 → 0.4.0

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

@@ -0,0 +1,44 @@
+import { type VNodeChild } from "vue";
+import { type HysConfig } from "../config";
+import type { HysModalProps, HysModalActionContext, HysModalCloseReason, HysModalSlotContext } from "./modal";
+export interface HysModalResult {
+    action: "confirm" | "cancel" | "destroy" | "owner-dispose";
+    reason: HysModalCloseReason | "destroy" | "owner-dispose";
+}
+export interface HysModalOptions extends Omit<HysModalProps, "open" | "modelValue" | "defaultOpen" | "fullscreen" | "appendTo"> {
+    content?: VNodeChild | ((context: HysModalSlotContext) => VNodeChild);
+    onOk?: (context: HysModalActionContext) => boolean | void | Promise<boolean | void>;
+    onCancel?: (context: HysModalActionContext) => boolean | void | Promise<boolean | void>;
+    onAfterClose?: (result: HysModalResult) => void;
+}
+export interface HysModalHandle {
+    readonly id: string;
+    readonly closed: Promise<HysModalResult>;
+    update(options: Partial<HysModalOptions>): void;
+    confirm(): Promise<boolean>;
+    cancel(): Promise<boolean>;
+    close(): Promise<boolean>;
+    destroy(): void;
+}
+export interface HysModalConfig {
+    defaults?: HysModalOptions;
+    appendTo?: string | HTMLElement;
+}
+export interface HysModalApi {
+    show(options: HysModalOptions): HysModalHandle;
+    confirm(options: HysModalOptions | string): HysModalHandle;
+    info(options: HysModalOptions | string): HysModalHandle;
+    success(options: HysModalOptions | string): HysModalHandle;
+    warning(options: HysModalOptions | string): HysModalHandle;
+    error(options: HysModalOptions | string): HysModalHandle;
+    destroyAll(): void;
+}
+export interface HysModalService extends HysModalApi {
+    dispose(): void;
+}
+export interface HysModalServiceConfig extends HysModalConfig, HysConfig {
+}
+/** Call in setup. Dialogs inherit ancestor providers and are disposed when their owner leaves. */
+export declare function useHysModal(config?: HysModalConfig): HysModalApi;
+/** Standalone browser service. Call dispose when its owning application is destroyed. */
+export declare function createHysModal(config?: HysModalServiceConfig): HysModalService;

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

@@ -0,0 +1,6 @@
+import { type Ref } from "vue";
+import type { FloatingAnchor } from "./useFloating";
+export declare function useMentionCaret(input: Readonly<Ref<HTMLElement | undefined>>, value: Readonly<Ref<string>>, start: () => number): {
+    anchor: import("vue").ComputedRef<FloatingAnchor | undefined>;
+    removeMirror: () => void;
+};

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

@@ -0,0 +1,23 @@
+import { type Ref } from "vue";
+import type { HysMentionProps } from "./mention";
+import type { MentionEntry } from "./useMentionOptions";
+type ListRow = {
+    key: string;
+    group: string;
+} | {
+    key: string;
+    entry: MentionEntry;
+    index: number;
+};
+export declare function useMentionList(props: HysMentionProps, choices: Readonly<Ref<readonly MentionEntry[]>>, element: Readonly<Ref<HTMLElement | undefined>>, loadMore: () => Promise<boolean>): {
+    rows: import("vue").ComputedRef<ListRow[]>;
+    enabled: import("vue").ComputedRef<MentionEntry[]>;
+    visibleRows: import("vue").ComputedRef<ListRow[]>;
+    topSpacer: import("vue").ComputedRef<number>;
+    bottomSpacer: import("vue").ComputedRef<number>;
+    rowHeight: import("vue").ComputedRef<number>;
+    onScroll: () => void;
+    reset: () => void;
+    ensureVisible: (key: string) => void;
+};
+export {};

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

@@ -0,0 +1,14 @@
+import type { HysMentionDocument, HysMentionEntity, HysMentionProps } from "./mention";
+import type { MentionSelection } from "./mentionEditor";
+export declare function mentionEntityKey(entity: HysMentionEntity): string;
+export declare function diffMentionEntities(previous: HysMentionEntity[], next: HysMentionEntity[]): {
+    added: HysMentionEntity[];
+    removed: HysMentionEntity[];
+};
+export declare function useMentionModel(props: HysMentionProps, publish: (next: HysMentionDocument, previous: HysMentionDocument, changedText: boolean) => void, accepted: (next: HysMentionDocument, previous: HysMentionDocument) => void): {
+    value: import("vue").ComputedRef<string>;
+    entities: import("vue").ComputedRef<HysMentionEntity[]>;
+    document: import("vue").ComputedRef<HysMentionDocument>;
+    commit: (next: HysMentionDocument, selection: MentionSelection, notify?: () => void, record?: boolean, force?: boolean) => Promise<boolean>;
+    history: (direction: "undo" | "redo", selection: MentionSelection) => Promise<MentionSelection | undefined>;
+};

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

@@ -0,0 +1,26 @@
+import { type Ref } from "vue";
+import type { HysMentionContext, HysMentionOption, HysMentionProps, HysMentionTrigger, HysMentionUser } from "./mention";
+export interface MentionEntry {
+    key: string;
+    option: HysMentionOption;
+    user: HysMentionUser;
+    created?: boolean;
+    remote?: boolean;
+}
+export declare function useMentionOptions(props: HysMentionProps, context: Readonly<Ref<HysMentionContext | undefined>>, trigger: Readonly<Ref<HysMentionTrigger | undefined>>, dismissed: Readonly<Ref<boolean>>, text: Readonly<Ref<string>>, onError: (error: unknown, context: HysMentionContext) => void): {
+    entries: import("vue").ComputedRef<MentionEntry[]>;
+    choices: import("vue").ComputedRef<MentionEntry[]>;
+    enabled: import("vue").ComputedRef<MentionEntry[]>;
+    busy: import("vue").ComputedRef<boolean>;
+    loadingMore: Ref<boolean, boolean>;
+    hasMore: import("vue").ComputedRef<boolean>;
+    loadError: import("vue").ShallowRef<{
+        reason: unknown;
+    } | undefined, {
+        reason: unknown;
+    } | undefined>;
+    retry: () => void;
+    loadMore: () => Promise<boolean>;
+    cancelLoad: () => void;
+    remember: (option: HysMentionOption, prefix: string) => void;
+};

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

@@ -0,0 +1,62 @@
+import { type Ref } from "vue";
+import type { HysModalProps, HysModalCloseReason } from "./modal";
+export declare function useModal(props: HysModalProps, dialog: Ref<HTMLElement | undefined>, emit: (name: string, ...args: any[]) => void, options?: {
+    interaction?: boolean;
+}): {
+    model: {
+        current: import("vue").ComputedRef<boolean>;
+        commit: (value: boolean, update: (value: boolean) => void, change: (value: boolean) => void, notifyOnRequest?: boolean) => Promise<boolean>;
+        reset: () => void;
+        invalidate: () => void;
+        isLive: () => boolean;
+    };
+    alpha: (value: number) => number;
+    fullscreen: import("vue").ComputedRef<boolean>;
+    live: Ref<boolean, boolean>;
+    state: {
+        active: import("vue").ComputedRef<boolean>;
+        zIndex: import("vue").ComputedRef<number>;
+        focus: () => void;
+    };
+    shown: Ref<boolean, boolean>;
+    engaged: Ref<boolean, boolean>;
+    rendered: Ref<boolean, boolean>;
+    leaving: Ref<boolean, boolean>;
+    error: Ref<string, string>;
+    confirming: import("vue").ComputedRef<boolean>;
+    closing: import("vue").ComputedRef<boolean>;
+    busy: import("vue").ComputedRef<boolean>;
+    motion: import("vue").ComputedRef<boolean>;
+    interaction: {
+        position: import("vue").ShallowRef<import("./modal").HysModalPosition, import("./modal").HysModalPosition>;
+        dimensions: import("vue").ShallowRef<import("./modal").HysModalSize | undefined, import("./modal").HysModalSize | undefined>;
+        previewing: Ref<boolean, boolean>;
+        previewLayer: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+        getPosition: () => import("./modal").HysModalPosition;
+        getDimensions: () => import("./modal").HysModalSize | undefined;
+        dragging: Ref<boolean, boolean>;
+        resizing: Ref<boolean, boolean>;
+        gesturing: import("vue").ComputedRef<boolean>;
+        start: (event: PointerEvent, kind: "drag" | "resize") => void;
+        stop: (cancel?: boolean) => void;
+        headerKey: (event: KeyboardEvent) => void;
+        resizeKey: (event: KeyboardEvent) => void;
+        resetPosition: () => void;
+        resetSize: () => void;
+        setPosition: (next: import("./modal").HysModalPosition) => void;
+        setSize: (next: import("./modal").HysModalSize) => void;
+        clampViewport: () => void;
+        activate(): void;
+    };
+    show: () => Promise<boolean>;
+    requestClose: (reasonOrEvent?: HysModalCloseReason | Event, event?: Event) => Promise<boolean>;
+    confirm: (event?: Event) => Promise<boolean>;
+    cancel: (event?: Event) => Promise<boolean>;
+    setFullscreen: (value: boolean) => Promise<boolean>;
+    toggleFullscreen: () => Promise<boolean>;
+    afterEnter: () => Promise<void>;
+    afterLeave: () => Promise<void>;
+    key: (event: KeyboardEvent) => void;
+    maskDown: (event: PointerEvent) => void;
+    maskUp: (event: PointerEvent) => void;
+};

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

@@ -0,0 +1,27 @@
+import { type Ref } from "vue";
+import { type HysModalProps, type HysModalPosition, type HysModalSize } from "./modal";
+export declare function useModalInteraction(props: HysModalProps, dialog: Ref<HTMLElement | undefined>, visible: Readonly<Ref<boolean>>, fullscreen: Readonly<Ref<boolean>>, emit: (name: string, ...args: any[]) => void, options?: {
+    beforeStart?: () => void;
+    motion?: () => boolean;
+    enabled?: boolean;
+}): {
+    position: import("vue").ShallowRef<HysModalPosition, HysModalPosition>;
+    dimensions: import("vue").ShallowRef<HysModalSize | undefined, HysModalSize | undefined>;
+    previewing: Ref<boolean, boolean>;
+    previewLayer: Ref<HTMLElement | undefined, HTMLElement | undefined>;
+    getPosition: () => HysModalPosition;
+    getDimensions: () => HysModalSize | undefined;
+    dragging: Ref<boolean, boolean>;
+    resizing: Ref<boolean, boolean>;
+    gesturing: import("vue").ComputedRef<boolean>;
+    start: (event: PointerEvent, kind: "drag" | "resize") => void;
+    stop: (cancel?: boolean) => void;
+    headerKey: (event: KeyboardEvent) => void;
+    resizeKey: (event: KeyboardEvent) => void;
+    resetPosition: () => void;
+    resetSize: () => void;
+    setPosition: (next: HysModalPosition) => void;
+    setSize: (next: HysModalSize) => void;
+    clampViewport: () => void;
+    activate(): void;
+};