@rokkit/core 1.0.0-next.112 → 1.0.0-next.114

package/dist/packages/actions/src/delegate.svelte.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Svelte action function for forwarding keyboard events from a parent element to a child.
+ * The child is selected using a CSS selector passed in the options object.
+ * Optionally, you can specify which keyboard events you want to forward: "keydown", "keyup", and/or "keypress".
+ * By default, all three events are forwarded.
+ *
+ * @param {HTMLElement} element - The parent element from which keyboard events will be forwarded.
+ * @param {import('./types').PushDownOptions} options - The options object.
+ * @returns {{destroy: Function}}
+ */
+export function delegateKeyboardEvents(element: HTMLElement, { selector, events }: import("./types").PushDownOptions): {
+    destroy: Function;
+};

package/dist/packages/actions/src/dismissable.svelte.d.ts

@@ -0,0 +1,7 @@
+/**
+ * A svelte action function that captures clicks outside the element or escape keypress
+ * emits a `dismiss` event. This is useful for closing a modal or dropdown.
+ *
+ * @param {HTMLElement} node
+ */
+export function dismissable(node: HTMLElement): void;

package/dist/packages/actions/src/fillable.svelte.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Action for filling a <del>?</del> element in html block.
+ *
+ * @param {HTMLElement} node
+ * @param {import('./types').FillOptions} options
+ * @returns
+ */
+export function fillable(node: HTMLElement, data: any): void;

package/dist/packages/actions/src/index.d.ts

@@ -0,0 +1,11 @@
+export * from "./types.js";
+export { keyboard } from "./keyboard.svelte.js";
+export { pannable } from "./pannable.svelte.js";
+export { swipeable } from "./swipeable.svelte.js";
+export { navigator } from "./navigator.svelte.js";
+export { themable } from "./themable.svelte.js";
+export { skinnable } from "./skinnable.svelte.js";
+export { dismissable } from "./dismissable.svelte.js";
+export { navigable } from "./navigable.svelte.js";
+export { fillable } from "./fillable.svelte.js";
+export { delegateKeyboardEvents } from "./delegate.svelte.js";

package/dist/packages/actions/src/kbd.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Gets keyboard action handlers based on orientation and direction
+ * @param {Object} options - Configuration options
+ * @param {Object} handlers - Event handler functions
+ * @returns {Object} Object mapping key presses to handler functions
+ */
+export function getKeyboardActions(options: Object, handlers: Object): Object;
+/**
+ * Creates a keyboard action mapping based on navigation options
+ *
+ * @param {Object} options - Navigation options
+ * @param {string} options.orientation - Whether navigation is horizontal or vertical
+ * @param {string} options.dir - Text direction ('ltr' or 'rtl')
+ * @param {boolean} options.nested - Whether navigation is nested
+ * @returns {Object} Mapping of keys to actions
+ */
+export function createKeyboardActionMap(options: {
+    orientation: string;
+    dir: string;
+    nested: boolean;
+}): Object;
+/**
+ * Creates a keyboard action mapping for modifier keys based on navigation options
+ *
+ * @param {Object} options - Navigation options
+ * @param {string} options.orientation - Whether navigation is horizontal or vertical
+ * @returns {Object} Mapping of keys to actions
+ */
+export function createModifierKeyboardActionMap(options: {
+    orientation: string;
+}): Object;
+/**
+ * Gets the keyboard action for a key event
+ * @param {KeyboardEvent} event - The keyboard event
+ * @param {Object} options - Configuration options
+ * @returns {string|null} The action to perform, or null if no action is defined
+ */
+export function getKeyboardAction(event: KeyboardEvent, options?: Object): string | null;
+export namespace defaultNavigationOptions {
+    let orientation: string;
+    let dir: string;
+    let nested: boolean;
+    let enabled: boolean;
+}

package/dist/packages/actions/src/keyboard.svelte.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Handle keyboard events
+ *
+ * @param {HTMLElement} root
+ * @param {import('./types.js').KeyboardConfig} options - Custom key mappings
+ */
+export function keyboard(root: HTMLElement, options?: import("./types.js").KeyboardConfig): void;

package/dist/packages/actions/src/lib/event-manager.d.ts

@@ -0,0 +1,8 @@
+/**
+ * EventManager class to manage event listeners on an element.
+ *
+ * @param {HTMLElement} element  - The element to listen for events on.
+ * @param {Object}      handlers - An object with event names as keys and event handlers as values.
+ * @returns {Object} - An object with methods to activate, reset, and update the event listeners.
+ */
+export function EventManager(element: HTMLElement, handlers?: Object, enabled?: boolean): Object;

package/dist/packages/actions/src/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./internal";
+export { EventManager } from "./event-manager";

package/dist/packages/actions/src/lib/internal.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Sets up event handlers based on the given options.
+ * Returns whether or not the event handlers are listening.
+ *
+ * @param {HTMLElement} element
+ * @param {import('../types').EventHandlers} listeners
+ * @param {import('../types').TraversableOptions} options
+ * @returns {void}
+ */
+export function setupListeners(element: HTMLElement, listeners: import("../types").EventHandlers, options: import("../types").TraversableOptions): void;
+/**
+ * Removes event handlers based on the given options.
+ * Returns whether or not the event handlers are listening.
+ *
+ * @param {HTMLElement} element
+ * @param {import('../types').EventHandlers} listeners
+ * @returns {void}
+ */
+export function removeListeners(element: HTMLElement, listeners: import("../types").EventHandlers): void;

package/dist/packages/actions/src/navigable.svelte.d.ts

@@ -0,0 +1,8 @@
+/**
+ * A svelte action function that captures keyboard evvents and emits event for corresponding movements.
+ *
+ * @param {HTMLElement} node
+ * @param {import('./types').NavigableOptions} options
+ * @returns {import('./types').SvelteActionReturn}
+ */
+export function navigable(node: HTMLElement, options: import("./types").NavigableOptions): import("./types").SvelteActionReturn;

package/dist/packages/actions/src/navigator.svelte.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The last only indicates that if there is an array only the last event is fired.
+ * This is crucial because a click event needs to fire both move and select,
+ * however the keyboard should only fire the select event because we are already
+ * on the current item
+ *
+ * @param {HTMLElement} root
+ * @param {*} controller
+ * @param {*} name
+ */
+export function emitAction(root: HTMLElement, controller: any, name: any, lastOnly?: boolean): void;
+export function handleAction(event: any, handler: any, path: any): any;
+/**
+ * A svelte action function that captures keyboard evvents and emits event for corresponding movements.
+ *
+ * @param {HTMLElement} node
+ * @param {import('./types').NavigableOptions} options
+ * @returns {import('./types').SvelteActionReturn}
+ */
+export function navigator(node: HTMLElement, options: import("./types").NavigableOptions): import("./types").SvelteActionReturn;

package/dist/packages/actions/src/pannable.svelte.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Makes an element pannable with mouse or touch events.
+ *
+ * @param {HTMLElement} node The DOM element to apply the panning action.
+ */
+export function pannable(node: HTMLElement): void;

package/dist/packages/actions/src/skinnable.svelte.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Applies theme variables to an element
+ * @param {HTMLElement} node - Element to apply variables to
+ * @param {Object.<string, string>} variables - CSS variables and their values
+ */
+export function skinnable(node: HTMLElement, variables: {
+    [x: string]: string;
+}): void;

package/dist/packages/actions/src/swipeable.svelte.d.ts

@@ -0,0 +1,14 @@
+/**
+ * A svelte action function that captures swipe actions and emits event for corresponding movements.
+ *
+ * @param {HTMLElement} node
+ * @param {import(./types).SwipeableOptions} options
+ * @returns {import('./types').SvelteActionReturn}
+ */
+export function swipeable(node: HTMLElement, options?: {
+    horizontal: boolean;
+    vertical: boolean;
+    threshold: number;
+    enabled: boolean;
+    minSpeed: number;
+}): import("./types").SvelteActionReturn;

package/dist/packages/actions/src/themable.svelte.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Update the theme attributes when the state changes.
+ *
+ * @param {HTMLElement} root
+ * @param {import('./types.js').ThemableConfig} options - Custom key mappings
+ */
+export function themable(root: HTMLElement, options: import("./types.js").ThemableConfig): void;

package/dist/packages/actions/src/types.d.ts

@@ -0,0 +1,72 @@
+export type EventMapping = {
+    /**
+     * - The event name
+     */
+    event: string;
+    /**
+     * - The keys that trigger the event
+     */
+    keys?: string[] | undefined;
+    /**
+     * - The pattern that triggers the event
+     */
+    pattern?: RegExp | undefined;
+};
+export type KeyboardConfig = {
+    [x: string]: RegExp | string[];
+};
+export type Direction = "vertical" | "horizontal";
+export type NavigatorOptions = {
+    /**
+     * - Whether the navigator is enabled
+     */
+    enabled: boolean;
+    /**
+     * - Whether the navigator is vertical or horizontal
+     */
+    direction: Direction;
+    /**
+     * - Whether the navigator supports multiple selections
+     */
+    multiselect: boolean;
+};
+export type DataWrapper = {
+    moveNext: Function;
+    movePrev: Function;
+    moveFirst: Function;
+    moveLast: Function;
+    expand: Function;
+    collapse: Function;
+    select: Function;
+    toggleExpansion: Function;
+};
+export type NavigatorActions = {
+    next: Function;
+    prev: Function;
+    first: Function;
+    last: Function;
+    expand: Function;
+    collapse: Function;
+    select: Function;
+};
+export type NavigatorConfig = {
+    /**
+     * - Whether the navigator is enabled
+     */
+    wrapper: Navigator;
+    /**
+     * - Whether the navigator is vertical or horizontal
+     */
+    options: NavigatorOptions;
+};
+export type Controller = {
+    moveNext: Function;
+    movePrev: Function;
+    moveFirst: Function;
+    moveLast: Function;
+    expand?: Function | undefined;
+    collapse?: Function | undefined;
+    select: Function;
+    extendSelection: Function;
+    toggleExpansion?: Function | undefined;
+};

package/dist/packages/actions/src/utils.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Finds the closest ancestor of the given element that has the given attribute.
+ *
+ * @param {HTMLElement} element
+ * @param {string} attribute
+ * @returns {HTMLElement|null}
+ */
+export function getClosestAncestorWithAttribute(element: HTMLElement, attribute: string): HTMLElement | null;
+export function handleAction(actions: any, event: any): void;
+/**
+ * Finds and returns an index path based on data-path attribute
+ *
+ * @param {MouseEvent} event
+ * @returns {number[]|null} null or index path array
+ */
+export function getPathFromEvent(event: MouseEvent): number[] | null;
+export function getEventForKey(keyMapping: import("./types.js").KeyboardConfig, key: string): string | null;
+export function getClickAction(event: MouseEvent): string;

package/dist/packages/bits-ui/src/index.d.ts

@@ -0,0 +1,2 @@
+export { default as List } from "./List.svelte";
+export { default as GroupedList } from "./GroupedList.svelte";

package/dist/packages/bits-ui/src/reference.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Gets the documentation path for a specific component
+ * @param {string} component - The component name
+ * @returns {string} The path to the documentation
+ */
+export function getDocPath(component: string): string;
+/**
+ * Gets the documentation URL for a specific component
+ * @param {string} component - The component name
+ * @returns {string} The URL to the documentation
+ */
+export function getDocUrl(component: string): string;
+export namespace DOCS {
+    let main: string;
+    let list: string;
+    namespace urls {
+        let main_1: string;
+        export { main_1 as main };
+        let list_1: string;
+        export { list_1 as list };
+    }
+}

package/dist/packages/bits-ui/src/tree/constants.d.ts

@@ -0,0 +1,13 @@
+export const TREE_ROOT_ATTR: "data-tree-root";
+export const TREE_LOADING_ATTR: "data-tree-loading";
+export const TREE_EMPTY_ATTR: "data-tree-empty";
+export const TREE_VIEWPORT_ATTR: "data-tree-viewport";
+export const TREE_LIST_ATTR: "data-tree-list";
+export const TREE_ITEM_ATTR: "data-tree-item";
+export const TREE_VALUE_ATTR: "data-value";
+export const TREE_LINE_ATTR: "data-tree-line";
+export const TREE_LINE_TYPE_ATTR: "data-tree-line-type";
+export const TREE_PATH_ATTR: "data-path";
+export const TREE_CTX: unique symbol;
+export const TREE_LINE_TYPES: string[];
+export const TREE_LINE_EMPTY: "empty";

package/dist/packages/bits-ui/src/tree/index.d.ts

@@ -0,0 +1,7 @@
+export { default as Root } from "./Root.svelte";
+export { default as Viewport } from "./Viewport.svelte";
+export { default as Node } from "./Node.svelte";
+export { default as NodeList } from "./NodeList.svelte";
+export { default as Line } from "./Line.svelte";
+export { default as Empty } from "./Empty.svelte";
+export { default as Loading } from "./Loading.svelte";

package/dist/packages/bits-ui/src/tree/types.d.ts

@@ -0,0 +1,71 @@
+export type TreeLineType = "empty" | "last" | "child" | "sibling";
+export type NodeStateIcons = {
+    /**
+     * - Icon for expanded state
+     */
+    expanded?: import("svelte").ComponentType<import("svelte").SvelteComponent<Record<string, any>, any, any>> | undefined;
+    /**
+     * - Icon for collapsed state
+     */
+    collapsed?: import("svelte").ComponentType<import("svelte").SvelteComponent<Record<string, any>, any, any>> | undefined;
+    /**
+     * - Icon for selected state
+     */
+    selected?: import("svelte").ComponentType<import("svelte").SvelteComponent<Record<string, any>, any, any>> | undefined;
+    /**
+     * - Icon for loading state
+     */
+    loading?: import("svelte").ComponentType<import("svelte").SvelteComponent<Record<string, any>, any, any>> | undefined;
+};
+export type TreeContext = {
+    /**
+     * - Tree controller
+     */
+    controller: import("@rokkit/states").NestedController;
+    /**
+     * - Tree items
+     */
+    items: Array<any>;
+    /**
+     * - Selected value
+     */
+    value: any;
+    /**
+     * - Field mappings
+     */
+    fields: import("@rokkit/core").FieldMapping;
+    /**
+     * - Icons for different node states
+     */
+    icons: NodeStateIcons;
+};
+export type TreeNodeEvent = {
+    /**
+     * - The node item
+     */
+    item: any;
+    /**
+     * - The node value
+     */
+    value: any;
+};
+export type TreeToggleEvent = {
+    /**
+     * - The node item
+     */
+    item: any;
+    /**
+     * - Whether the node is expanded
+     */
+    expanded: boolean;
+};
+export type TreeMoveEvent = {
+    /**
+     * - The node item
+     */
+    item: any;
+    /**
+     * - Move direction
+     */
+    direction: string;
+};

package/dist/packages/core/src/calendar.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Get the days in the month.
+ *
+ * @param {Date}    value
+ * @param {Array}   holidays
+ * @param {boolean} fixed
+ * @returns {import('./types').CalendarDay[]}
+ */
+export function getCalendarDays(value: Date, holidays?: any[], fixed?: boolean): import("./types").CalendarDay[];
+export const weekdays: string[];