@knitify/vue 1.0.0 → 2.1.0

package/dist/types/components/ChatDock/keys.d.ts

@@ -0,0 +1,98 @@
+import type { InjectionKey, ShallowRef } from 'vue';
+import type Knitify from '@knitify/core';
+export type ChatDockInstance = InstanceType<typeof Knitify.modules.ChatDock>;
+/**
+ * What `withModule` did, so a caller can react to each outcome distinctly:
+ *
+ * - `'called'` — the callback ran against a live module. Anything the caller
+ *   wanted to tell core has been told.
+ * - `'deferred'` — a dock is present but its first `init()` has not run yet,
+ *   so nothing may reach core (see `withModule`). The callback did **not**
+ *   run; the caller must record its intent through `declare` instead, and the
+ *   dock replays it the moment calling core becomes safe.
+ * - `'unavailable'` — there is no module to call at all: no `KChatDock`
+ *   ancestor, or the dock's own root is gone. The callback did **not** run and
+ *   nothing was or will be recorded, so a caller must not update bookkeeping
+ *   that claims core was told something.
+ */
+export type ChatDockCallResult = 'called' | 'deferred' | 'unavailable';
+export type ChatDockContext = {
+    /**
+     * **The only way to reach core from anywhere in this component pair.** The
+     * module instance is deliberately not exposed: a call site that cannot get
+     * hold of it cannot skip the gate below by accident, which is what four
+     * successive rounds of path-specific patching kept failing to prevent.
+     *
+     * The gate: no core call may happen before the dock's own first deferred
+     * `init()` has run. Every core method reflows synchronously before it
+     * returns, and a reflow dispatches `kt.chatdock.rail`/`.unrail` to whichever
+     * windows changed — but a child window attaches those listeners from a
+     * template-ref watcher, which lands a flush *after* its parent's
+     * `onMounted`, and Vue orders pre-flush jobs by component creation order, so
+     * the dock's own watchers and an earlier sibling's watchers all run while a
+     * later sibling is still deaf. An event dropped that way is lost for good:
+     * Vue never re-patches a `class` binding whose rendered string is unchanged,
+     * so core's directly-set `is-railed` survives on the element while
+     * `v-model:state` (and `aria-expanded`) stay wrong forever, and every later
+     * reflow is a no-op diff that never repairs it.
+     *
+     * Skipping a pre-init call costs nothing, which is what makes the gate safe
+     * rather than merely cautious: the deferred `init()` applies every pending
+     * declaration and reflows anyway, so it subsumes whatever was skipped.
+     *
+     * Also flushes any pending declarations through core immediately before
+     * running the callback, so a `reflow()` never computes capacity against a
+     * window core has not yet been told is railed.
+     */
+    withModule: (run: (module: ChatDockInstance) => void) => ChatDockCallResult;
+    /**
+     * Records whether a window should be railed once the dock next applies its
+     * declarations — no class, no attribute, no method call yet. `KChatDock`
+     * plays every recorded declaration through core itself, from its deferred
+     * first `init()` and again before every later core call (see `withModule`),
+     * which are the only points every window is guaranteed to have already
+     * attached its own `kt.chatdock.*` listeners.
+     *
+     * This is where state intent goes whenever `withModule` reports
+     * `'deferred'`, and where a window's own initial non-expanded state goes at
+     * mount.
+     *
+     * With only two states left, this only ever records `railed` — an
+     * `'expanded'` window needs nothing (that's what a freshly-seeded window
+     * already is), and `railed` needs a core call because only core's `rail()`
+     * sets the `data-kt-chat-window-minimized` marker `reflow()` reads to tell
+     * an explicit minimize apart from a window merely ranked below capacity.
+     *
+     * Idempotent both ways: declaring the same element `railed` repeatedly, or
+     * un-declaring it (passing `false`) before it's ever applied, just leaves
+     * one net entry (or none) — whichever a window's most recent write before
+     * the dock's next apply says is true.
+     */
+    declare: (element: HTMLElement, railed: boolean) => void;
+    /**
+     * The rail element, as a ref, so a window can teleport its head into it.
+     *
+     * A ref rather than the element itself because the rail is rendered by the
+     * dock and a window may set up before it resolves; `<Teleport defer>`
+     * handles a target that appears later in the same tree, and the ref is what
+     * lets the window react when it does.
+     *
+     * This is not a way around the gate: teleporting renders markup, it does
+     * not call core. Every core call still goes through `withModule`.
+     */
+    rail: Readonly<ShallowRef<HTMLElement | null>>;
+    /**
+     * The popover list element, as a ref, so a window can teleport its row into
+     * it. Same shape and reasoning as `rail`: the dock renders it, a window may
+     * set up before it resolves, and `<Teleport defer>` handles a target that
+     * appears later in the same tree.
+     */
+    list: Readonly<ShallowRef<HTMLElement | null>>;
+    /**
+     * The row zone element, as a ref, so `KChatDockPanel` can teleport into it.
+     * Same shape and reasoning as `rail` and `list`. The panel's `order: -1`
+     * places it beside the rail regardless of where the teleport appends it.
+     */
+    panel: Readonly<ShallowRef<HTMLElement | null>>;
+};
+export declare const chatDockKey: InjectionKey<ChatDockContext>;

package/dist/types/components/ChatDock/messenger-types.d.ts

@@ -0,0 +1,335 @@
+import type { ComputedRef, Ref } from 'vue';
+export type ChatConversation = {
+    id: string;
+    name: string;
+    /** Image URL; the avatar falls back to initials from `name`. */
+    avatar?: string;
+    /** Last message line, shown in the panel row. */
+    preview?: string;
+    unread?: number;
+    /** ISO timestamp; when present the panel sorts newest first. */
+    updatedAt?: string;
+    /**
+     * Untouched by the store — carry app-specific payload through to the slots.
+     * Replaced, not merged, when `refreshConversations` returns a conversation
+     * that carries one: the merge is a shallow spread.
+     */
+    meta?: unknown;
+};
+export type ChatMessage = {
+    id: string;
+    conversationId: string;
+    text: string;
+    /** `true` for the current user; drives `KChatMessage`'s `sender`. */
+    sender: boolean;
+    /** Display string, e.g. "10:42 AM". */
+    time?: string;
+    /** ISO timestamp, for ordering by the server. */
+    sentAt?: string;
+    /** Optimistic send in flight; cleared when `sendMessage` resolves. */
+    pending?: boolean;
+    /** `sendMessage` rejected; the message shows a retry control. */
+    failed?: boolean;
+    /**
+     * Untouched by the store — carry app-specific payload through to the slots.
+     * An optimistic message created by `send()` has none; the message returned
+     * by `sendMessage` replaces it wholesale, so `meta` appears when the server
+     * response does.
+     */
+    meta?: unknown;
+};
+export type ChatMessagesPage = {
+    messages: ChatMessage[];
+    /** `null` or `undefined` means there is nothing older. */
+    nextCursor?: string | null;
+};
+export type ChatDockLoaders = {
+    loadConversations: () => Promise<ChatConversation[]>;
+    /** Chronological within the page (oldest first). `cursor` asks for older. */
+    loadMessages: (id: string, cursor?: string) => Promise<ChatMessagesPage>;
+    /** Optional; without it the composer is hidden. */
+    sendMessage?: (id: string, text: string) => Promise<ChatMessage>;
+    /** Optional; called when a window expands. Unread is zeroed locally either way. */
+    markRead?: (id: string) => Promise<void>;
+};
+export type ChatDockOptions = {
+    /** Drop messages, cursor and draft when a window closes. Default `false`. */
+    evictOnClose?: boolean;
+    /**
+     * Skip the list load the store otherwise starts on creation; nothing is
+     * fetched until `ensureConversations` (or `refreshConversations`) is
+     * called. `KMessenger` calls it when the panel first opens. Default `false`.
+     */
+    lazy?: boolean;
+};
+export type ChatWindowState = 'closed' | 'expanded' | 'railed';
+export type LoadState = 'idle' | 'loading' | 'loaded' | 'error';
+export type ChatEntry = {
+    conversation: ChatConversation;
+    window: ChatWindowState;
+    messages: ChatMessage[];
+    /** `undefined` until the first page loads; `null` when nothing older exists. */
+    cursor: string | null | undefined;
+    loading: LoadState;
+    loadingOlder: boolean;
+    error?: unknown;
+    draft: string;
+};
+export type ChatDockErrorKind = 'conversations' | 'messages' | 'send';
+export type ChatDockStore = {
+    /** Sorted newest first when `updatedAt` is present on every entry. */
+    conversations: ComputedRef<ChatConversation[]>;
+    entries: Record<string, ChatEntry>;
+    /** Ids whose window is not `'closed'`, most recently opened first. */
+    openIds: ComputedRef<string[]>;
+    listLoading: Ref<LoadState>;
+    listError: Ref<unknown>;
+    query: Ref<string>;
+    /** Whether a composer can be rendered at all. */
+    canSend: boolean;
+    refreshConversations: () => Promise<void>;
+    /**
+     * Loads the list only if it has not loaded yet: starts a load when idle or
+     * failed, joins the one in flight, and does nothing once loaded. Safe to
+     * call on every panel open.
+     */
+    ensureConversations: () => Promise<void>;
+    open: (id: string) => Promise<void>;
+    /**
+     * Shows a window again without treating it as a user-initiated open: no
+     * rank change, no unread reset, no `markRead`, no `'open'` event. For a
+     * reflow un-railing a window; use `open` for a real choice.
+     */
+    expand: (id: string) => Promise<void>;
+    minimize: (id: string) => void;
+    close: (id: string) => void;
+    loadOlder: (id: string) => Promise<void>;
+    send: (id: string, text: string) => Promise<void>;
+    retry: (id: string, messageId: string) => Promise<void>;
+    retryLoad: (id: string) => Promise<void>;
+    receive: (message: ChatMessage) => void;
+    setDraft: (id: string, text: string) => void;
+    setQuery: (text: string) => void;
+    /**
+     * Fires after an action outcome, so a component can mirror it as an emit.
+     * Returns an unsubscribe function.
+     */
+    onEvent: (listener: (event: ChatDockEvent) => void) => () => void;
+};
+export type ChatDockEvent = {
+    type: 'open';
+    id: string;
+} | {
+    type: 'close';
+    id: string;
+} | {
+    type: 'send';
+    message: ChatMessage;
+} | {
+    type: 'receive';
+    message: ChatMessage;
+} | {
+    type: 'error';
+    kind: ChatDockErrorKind;
+    id?: string;
+    error: unknown;
+};
+export type KMessengerProps = {
+    /** The component creates its own store. Exactly one of `loaders` or `store`. */
+    loaders?: ChatDockLoaders;
+    /** A store created with `useChatDock` elsewhere and shared. */
+    store?: ChatDockStore;
+    minWindows?: number;
+    title?: string;
+    placeholder?: string;
+    /** The "New chat" window's title. Default `'New Chat'`. */
+    newChatTitle?: string;
+    /** The "New chat" people search placeholder. Default `'To: Search People'`. */
+    newChatPlaceholder?: string;
+    /** The "New chat" people search's accessible name. Default `'Search people'`. */
+    newChatSearchLabel?: string;
+    /** Passed to `useChatDock` when the component creates the store. */
+    evictOnClose?: boolean;
+    /**
+     * Passed to `useChatDock` when the component creates the store: the list
+     * loads when the panel first opens instead of on mount. Default `false`.
+     */
+    lazy?: boolean;
+    /**
+     * Passed to every window's `KChat`: stacks message actions under the bubble.
+     * Defaults to `true` — a dock window is too narrow to spare the width beside
+     * each bubble. Pass `false` to put them back at the side.
+     */
+    actionsBottom?: boolean;
+    /**
+     * Called for each message with the one before it. Return a label to render
+     * a divider above that message, or `undefined` for none. `previous` is
+     * `undefined` for the first message in the list.
+     *
+     * A boundary hook, not a date hook: an app tracking its own unread boundary
+     * returns "Unread messages" there and a day label elsewhere.
+     *
+     * Called for every message on every render, so compare pre-computed day
+     * keys here rather than parsing and formatting inside the callback.
+     */
+    dateLabel?: (message: ChatMessage, previous?: ChatMessage) => string | undefined;
+    /**
+     * Return a label to render this message as a `KChatNotice` instead of a
+     * `KChatMessage`. `undefined` renders it as a normal bubble.
+     *
+     * For an event that arrives in the same message stream as ordinary
+     * messages and is distinguished per message — "You left the meeting room",
+     * "Call ended at 01:48 PM".
+     *
+     * A notice renders no bubble, no sender side, no time and no actions row,
+     * and so no retry control either: a message carrying both `failed` and a
+     * notice label loses the way to retry it. Return `undefined` for a message
+     * still in flight. `dateLabel` still applies above a notice, so a day
+     * divider can precede one.
+     *
+     * Called for every message on every render, like `dateLabel` — read a
+     * pre-computed field here rather than deriving one inside the callback.
+     */
+    noticeLabel?: (message: ChatMessage) => string | undefined;
+};
+export type KMessengerEmits = {
+    open: [id: string];
+    close: [id: string];
+    send: [message: ChatMessage];
+    receive: [message: ChatMessage];
+    error: [kind: ChatDockErrorKind, id: string | undefined, error: unknown];
+    /** The panel's write button was clicked; the "New chat" window is open. */
+    compose: [];
+    /** Each keystroke in the "New chat" window's people search. */
+    'new-chat-search': [query: string];
+    /** The "New chat" window was closed. */
+    'new-chat-close': [];
+};
+export type KMessengerSlots = {
+    /** Inside the avatar circle of a head and a panel row. */
+    avatar?(props: {
+        conversation: ChatConversation;
+    }): any;
+    /**
+     * The window header's action area, before the minimize and close controls.
+     * `window-` prefixed because an unprefixed `title` would read as the dock's
+     * own title, which is already a prop, and `actions` would collide with the
+     * panel's.
+     */
+    'window-actions'?(props: {
+        conversation: ChatConversation;
+        entry: ChatEntry;
+    }): any;
+    /** The window header's title text. */
+    'window-title'?(props: {
+        conversation: ChatConversation;
+        entry: ChatEntry;
+    }): any;
+    /** Inside a railed head's avatar circle. Falls back to `avatar`. */
+    head?(props: {
+        conversation: ChatConversation;
+        entry: ChatEntry;
+    }): any;
+    /** Inside a `+N` popover row's avatar. Falls back to `avatar`. */
+    row?(props: {
+        conversation: ChatConversation;
+        entry: ChatEntry;
+    }): any;
+    /** The panel header's action area, before the write, maximize and close. */
+    'panel-actions'?(): any;
+    /**
+     * The "New chat" window's body, under its people search — e.g. a "Create
+     * New Group" link and suggested people. `close` dismisses the window, for
+     * once a person is picked.
+     */
+    'new-chat'?(props: {
+        close: () => void;
+    }): any;
+    /** The whole panel row. */
+    item?(props: {
+        conversation: ChatConversation;
+        entry: ChatEntry;
+    }): any;
+    /** One message bubble's content. */
+    message?(props: {
+        message: ChatMessage;
+        conversation: ChatConversation;
+    }): any;
+    /**
+     * The hover row beside a message's bubble — put a `KChatMessageActions`
+     * here. `message-` prefixed to match `window-actions` and `panel-actions`,
+     * which are the two headers rather than a message.
+     *
+     * Forwarded only when you pass it, so `KChatMessage`'s own empty actions
+     * rendering is unchanged otherwise. Not rendered for a message that
+     * `noticeLabel` turned into a notice.
+     */
+    'message-actions'?(props: {
+        message: ChatMessage;
+        conversation: ChatConversation;
+    }): any;
+    /** The window footer. */
+    composer?(props: {
+        conversation: ChatConversation;
+        draft: string;
+        send: (text: string) => void;
+        setDraft: (text: string) => void;
+    }): any;
+    /**
+     * Extra controls on the default composer, scoped by conversation so one
+     * template serves every window: `prefix`/`suffix` inside the field border,
+     * `start`/`end` outside it (`end` sits before the send button). Ignored
+     * when `composer` replaces the whole footer.
+     */
+    'composer-prefix'?(props: {
+        conversation: ChatConversation;
+    }): any;
+    'composer-suffix'?(props: {
+        conversation: ChatConversation;
+    }): any;
+    'composer-start'?(props: {
+        conversation: ChatConversation;
+    }): any;
+    'composer-end'?(props: {
+        conversation: ChatConversation;
+    }): any;
+    /** Window body while the first page loads. */
+    loading?(props: {
+        conversation: ChatConversation;
+    }): any;
+    /**
+     * The list row shown while an older page loads. Rendered inside the
+     * message `<ul>`, so its root must be an `<li>`.
+     */
+    'loading-older'?(props: {
+        conversation: ChatConversation;
+    }): any;
+    /** Window body when the first page failed. */
+    error?(props: {
+        conversation: ChatConversation;
+        error: unknown;
+        retry: () => void;
+    }): any;
+    /** Panel text when the filter matches nothing. */
+    empty?(): any;
+    launcher?(): any;
+    /**
+     * Replaces the rendered divider while keeping `dateLabel`'s positioning.
+     * Whatever you render must be an `<li>`: it is a direct child of the
+     * message list's `<ul>`.
+     */
+    divider?(props: {
+        label: string;
+        message: ChatMessage;
+        previous?: ChatMessage;
+    }): any;
+    /**
+     * Replaces the rendered notice while keeping `noticeLabel`'s decision.
+     * Whatever you render must be an `<li>`: it is a direct child of the
+     * message list's `<ul>`.
+     */
+    notice?(props: {
+        label: string;
+        message: ChatMessage;
+    }): any;
+};

package/dist/types/components/ChatDock/store-keys.d.ts

@@ -0,0 +1,7 @@
+import { type InjectionKey } from 'vue';
+import type { ChatDockStore } from './messenger-types';
+export declare const chatDockStoreKey: InjectionKey<ChatDockStore>;
+/** Shares a store created with `useChatDock` with the component subtree. */
+export declare function provideChatDock(store: ChatDockStore): void;
+/** The store an ancestor provided, or `undefined` outside one. */
+export declare function injectChatDock(): ChatDockStore | undefined;

package/dist/types/components/ChatDock/types.d.ts

@@ -0,0 +1,162 @@
+export type KChatWindowState = 'expanded' | 'railed';
+export type KChatDockProps = {
+    /**
+     * Capacity floor, so a narrow dock still shows one window rather than
+     * nothing but heads. Gap, offset and window dimensions are deliberately not
+     * props — they are the CSS variables registered on `.KChatDock`, and the
+     * module measures them back rather than being told them twice.
+     */
+    minWindows?: number;
+};
+export type KChatDockEmits = {
+    reflow: [];
+    launcher: [];
+    /**
+     * The panel's write button was clicked. The dock mounts nothing itself —
+     * render a `KChatNewWindow` (or anything else) in response.
+     */
+    compose: [];
+    /** After the panel opens or closes. */
+    panel: [open: boolean];
+    /** After each filter, including the reset when the panel closes. */
+    search: [query: string];
+    /**
+     * An item was picked. `opened` is `true` when the dock expanded an existing
+     * `KChatWindow` with that id itself; `false` means the app must mount one.
+     */
+    select: [id: string, opened: boolean];
+    /**
+     * A user expanded a railed window from its head, a `+N` popover row, or the
+     * window's own toggle. Distinct from `update:state` on the window, which
+     * also fires when a reflow un-rails by capacity.
+     */
+    activate: [id: string];
+};
+export type KChatDockSlots = {
+    default?(): any;
+    launcher?(): any;
+};
+/**
+ * `KChatWindow` teleports its head into the dock's rail, which makes it a
+ * multi-root (Fragment) component — unlike every other component in this
+ * package. A template `ref` on it resolves `$el` to the fragment's anchor
+ * text node, not the window element, so reading DOM properties (e.g.
+ * `.classList`) off that ref will throw.
+ */
+export type KChatWindowProps = {
+    closable?: boolean;
+    minimizable?: boolean;
+    title?: string;
+    unread?: number;
+    /**
+     * Links this window to its head in the rail. Core reads it from
+     * `data-kt-chat-window` to pair the two, so a window without one gets no
+     * head — which is legitimate, just headless.
+     */
+    id?: string;
+};
+export type KChatWindowEmits = {
+    close: [];
+};
+export type KChatWindowSlots = {
+    actions?(): any;
+    /**
+     * The fallback for `head` and `row` — a railed head's circle and a `+N`
+     * popover row. It does NOT appear in an open window's header: the title
+     * already names the conversation there, and the 320px header has the
+     * minimize and close controls competing for it.
+     */
+    avatar?(): any;
+    default?(): any;
+    /** A railed head's circle. Falls back to `avatar` when not given. */
+    head?(): any;
+    /**
+     * A full-width row under the title and actions, inside the header — e.g.
+     * the people search of `KChatNewWindow`. Rendered only when passed.
+     */
+    search?(): any;
+    /** The popover row's avatar. Falls back to `avatar` when not given. */
+    row?(): any;
+    title?(): any;
+};
+export type KChatNewWindowProps = {
+    /** Pairs the window with its rail head, as `KChatWindow`'s `id` does. */
+    id?: string;
+    title?: string;
+    /** People search placeholder. */
+    placeholder?: string;
+    /** People search's accessible name. Default `'Search people'`. */
+    searchLabel?: string;
+};
+export type KChatNewWindowEmits = {
+    /** On every keystroke in the people search. */
+    search: [query: string];
+    close: [];
+};
+export type KChatNewWindowSlots = {
+    /** The body under the search: e.g. a "Create New Group" link, suggestions. */
+    default?(): any;
+};
+export type KChatDockPanelProps = {
+    /** Header text. */
+    title?: string;
+    /** Search field placeholder. */
+    placeholder?: string;
+};
+/**
+ * `KChatDockPanel` teleports into the dock's row zone, so it is multi-root
+ * like `KChatWindow`: a template `ref` on it resolves `$el` to a fragment
+ * anchor, not the panel element.
+ */
+export type KChatDockPanelSlots = {
+    /** `KChatDockItem`s. */
+    default?(): any;
+    /**
+     * Header controls, between the title and the built-in write, maximize and
+     * close buttons — so close stays last in the DOM and in the tab order.
+     *
+     * Controls here bind their own handlers. Do not put
+     * `data-kt-chat-dock-item` on anything in this slot: `KChatDock`'s root
+     * click handler routes that attribute as a conversation selection.
+     */
+    actions?(): any;
+    /** Replaces the "No conversations found" text. */
+    empty?(): any;
+};
+export type KChatDockItemProps = {
+    /** Conversation id, the same page-wide id space as `KChatWindow`'s `id`. */
+    id: string;
+    name: string;
+    /** One-line last-message preview, muted and truncated. */
+    preview?: string;
+    unread?: number;
+};
+export type KChatDockItemSlots = {
+    /** Inside the avatar circle. Falls back to initials from `name`. */
+    avatar?(): any;
+    /**
+     * Replaces the avatar circle entirely, for an app that draws its own — a
+     * stack of participant avatars for a group, a presence dot overlaid on the
+     * photo. `avatar` fills the built-in circle; this one stands in for it, so
+     * use it instead of nesting a circle inside `KAvatar`.
+     *
+     * Like `trailing`, this renders inside the row's own `<button>`: keep the
+     * content non-interactive, or the parser closes the button early and breaks
+     * `data-kt-chat-dock-item` click routing for every row after it.
+     */
+    media?(): any;
+    /**
+     * After the body, where the unread badge sits. Falls back to that badge, so
+     * a row that does not use this slot is unchanged. Replacing the badge does
+     * not change the row's accessible name, which still folds in `unread` —
+     * keep the two consistent or pass a matching `unread`.
+     *
+     * This slot renders inside the row's own `<button>` — non-interactive
+     * content only (a badge, a timestamp). A nested `<button>` (e.g. a mute
+     * control) is invalid HTML: the parser repairs it by closing the outer
+     * button early, corrupting the row and breaking
+     * `data-kt-chat-dock-item` click routing for everything after it. For a
+     * real control, render it outside the row instead.
+     */
+    trailing?(): any;
+};

package/dist/types/components/ChatDock/useChatDock.d.ts

@@ -0,0 +1,11 @@
+import type { ChatDockLoaders, ChatDockOptions, ChatDockStore } from './messenger-types';
+/**
+ * Owns everything about a dock's conversations except the DOM: which windows
+ * are open, each one's messages, cursor, loading state, error and draft, and
+ * every call to the app's loaders. `KMessenger` renders it; any component can
+ * hold the same instance through `provideChatDock` / `injectChatDock`.
+ *
+ * Every action is idempotent and safe before the list has loaded. None throws:
+ * a loader rejection becomes `error` / `listError` and an `'error'` event.
+ */
+export declare function useChatDock(loaders: ChatDockLoaders, options?: ChatDockOptions): ChatDockStore;

package/dist/types/components/Collapse/KCollapse.vue.d.ts

@@ -10,16 +10,16 @@ declare const __VLS_base: import("vue").DefineComponent<__VLS_PublicProps, {
     expand: () => boolean;
     collapse: () => boolean;
 }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    expanded: () => any;
     collapse: () => any;
     collapsed: () => any;
     expand: () => any;
-    expanded: () => any;
     "update:expanded": (value: boolean) => any;
 }, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onExpanded?: (() => any) | undefined;
     onCollapse?: (() => any) | undefined;
     onCollapsed?: (() => any) | undefined;
     onExpand?: (() => any) | undefined;
-    onExpanded?: (() => any) | undefined;
     "onUpdate:expanded"?: ((value: boolean) => any) | undefined;
 }>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
 declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;

package/dist/types/components/Collapse/useCollapseSync.d.ts

@@ -10,11 +10,13 @@ export type CollapseSyncOptions = {
 /**
  * Two-way binding between a `v-model` and core's Collapse module.
  *
- * `data-kt-collapse` stays on the element, so core's delegated toggle keeps
- * working — including `data-kt-collapse-group`, where opening one pane closes
- * its siblings through core rather than through Vue. Each sibling hears its own
- * `kt.collapse` and updates its own model, so grouping needs no coordination
- * here.
+ * `data-kt-collapse` stays on the element, so `data-kt-collapse-group` keeps
+ * working: opening one pane closes its siblings inside core's `expand()` rather
+ * than through Vue. Each sibling hears its own `kt.collapse` and updates its own
+ * model, so grouping needs no coordination here.
+ *
+ * The toggle click is bound below rather than left to core's delegated handler,
+ * so a collapse works in an app that never called `Knitify.init()`.
  *
  * The guard is `moduleExpanded` — which way the module is actually going —
  * rather than a flag set around the model write. Vue 3.5 batches reactive

package/dist/types/components/DateInput/KDateInput.vue.d.ts

@@ -0,0 +1,26 @@
+import type { KDateInputInvalidReason, KDateInputProps } from './types';
+type __VLS_Props = KDateInputProps;
+type __VLS_ModelProps = {
+    modelValue?: Date | null;
+};
+type __VLS_PublicProps = __VLS_Props & __VLS_ModelProps;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_PublicProps, {
+    clear: () => null;
+    close: () => void | undefined;
+    focus: () => void | undefined;
+    open: () => void | undefined;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    open: () => any;
+    close: () => any;
+    invalid: (reason: KDateInputInvalidReason, text: string) => any;
+    clear: () => any;
+    "update:modelValue": (value: Date | null) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onOpen?: (() => any) | undefined;
+    onClose?: (() => any) | undefined;
+    onInvalid?: ((reason: KDateInputInvalidReason, text: string) => any) | undefined;
+    onClear?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((value: Date | null) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;