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

package/dist/packages/states/src/constants.d.ts

@@ -0,0 +1,27 @@
+export namespace DEFAULT_EVENTS {
+    export { noop as move };
+    export { noop as select };
+    export { noop as expand };
+    export { noop as collapse };
+}
+export const VALID_DENSITIES: string[];
+export const VALID_MODES: string[];
+/** @type {string[]} */
+export const DEFAULT_STYLES: string[];
+export namespace DEFAULT_VIBE_OPTIONS {
+    export { DEFAULT_STYLES as allowed };
+    export let style: string;
+    export let mode: string;
+    export let density: string;
+}
+export namespace DEFAULT_VIBE_PALETTE {
+    let primary: string;
+    let secondary: string;
+    let success: string;
+    let info: string;
+    let warning: string;
+    let danger: string;
+    let light: string;
+    let dark: string;
+}
+import { noop } from '@rokkit/core';

package/dist/packages/states/src/derive.svelte.d.ts

@@ -0,0 +1,22 @@
+/**
+ *
+ * @param {Array<*>} items
+ * @param {import('@rokkit/core').FieldMapping} fields
+ * @param {Array<number>} path
+ * @returns {Array<{ key: string, value: any }>}
+ */
+export function flatVisibleNodes(items: Array<any>, fields?: import("@rokkit/core").FieldMapping, path?: Array<number>): Array<{
+    key: string;
+    value: any;
+}>;
+/**
+ * Derives a flat lookup table for the given items, using index paths as keys
+ * Each value is a Proxy instance for convenient manipulation
+ *
+ * @param {Array<*>} items - Source items array
+ * @param {import('@rokkit/core').FieldMapping} fields - Field mappings configuration
+ * @param {Array<number>} path - Current path in the tree
+ * @returns {Map<string, Proxy>} - Map of path keys to Proxy instances
+ */
+export function deriveLookupWithProxy(items: Array<any>, fields?: import("@rokkit/core").FieldMapping, path?: Array<number>): Map<string, Proxy>;
+import { Proxy } from './proxy.svelte';

package/dist/packages/states/src/hierarchy.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @typedef {Object} HierarchyItem
+ * @property {number} depth - The depth of the item in the hierarchy.
+ * @property {Array<number>} path - The path of the item in the hierarchy.
+ * @property {any} item   - The item itself.
+ * @property {HierarchyItem} parent - The reference to the parent item.
+ */
+/**
+ * Converts a hierarchy of items into a flat array of objects.
+ *ß
+ * @param {Array<any>}                         items - The array of items to convert.
+ * @param {import('@rokkit/core').FieldMapper} mapping - The field mapper to use for mapping.
+ * @param {HierarchyItem}                      parent - The current path of the item.
+ * @returns {Array<Object>} - The flat array of objects.
+ */
+export function flatHierarchy(items: Array<any>, mapping: import("@rokkit/core").FieldMapper, parent?: HierarchyItem): Array<Object>;
+export type HierarchyItem = {
+    /**
+     * - The depth of the item in the hierarchy.
+     */
+    depth: number;
+    /**
+     * - The path of the item in the hierarchy.
+     */
+    path: Array<number>;
+    /**
+     * - The item itself.
+     */
+    item: any;
+    /**
+     * - The reference to the parent item.
+     */
+    parent: HierarchyItem;
+};

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

@@ -0,0 +1,5 @@
+export { TableWrapper } from "./tabular.svelte";
+export { Proxy } from "./proxy.svelte";
+export { vibe } from "./vibe.svelte";
+export { ListController } from "./list-controller.svelte";
+export { NestedController } from "./nested-controller.svelte";

package/dist/packages/states/src/list-controller.svelte.d.ts

@@ -0,0 +1,70 @@
+export class ListController {
+    constructor(items: any, value: any, fields: any, options: any);
+    items: null;
+    fields: any;
+    mappers: any[];
+    selectedKeys: SvelteSet<any>;
+    focusedKey: null;
+    selected: null[];
+    focused: null | undefined;
+    data: {
+        key: string;
+        value: any;
+    }[];
+    lookup: Map<string, import("./proxy.svelte").Proxy>;
+    /**
+     * @private
+     * @param {Array<*>} items
+     * @param {*} value
+     */
+    private init;
+    get isNested(): boolean;
+    get currentKey(): null;
+    /**
+     * @private
+     * @param {*} value
+     * @returns
+     */
+    private findByValue;
+    /**
+     * @private
+     * @param {*} value
+     * @returns
+     */
+    private moveToValue;
+    /**
+     *
+     * @param {string} path
+     * @returns
+     */
+    moveTo(path: string): boolean;
+    /**
+     * @private
+     * @param {number} index
+     */
+    private moveToIndex;
+    movePrev(): boolean;
+    moveNext(): boolean;
+    moveFirst(): boolean;
+    moveLast(): boolean;
+    /**
+     * Toggles the selection.
+     * @private
+     * @param {string} key
+     */
+    private toggleSelection;
+    /**
+     *
+     * @param {string} selectedKey
+     * @returns
+     */
+    select(selectedKey: string): boolean;
+    /**
+     *
+     * @param {string} selectedKey
+     * @returns
+     */
+    extendSelection(selectedKey: string): boolean;
+    #private;
+}
+import { SvelteSet } from 'svelte/reactivity';

package/dist/packages/states/src/nested-controller.svelte.d.ts

@@ -0,0 +1,32 @@
+export class NestedController extends ListController {
+    /**
+     * @protected
+     * @param {Object} [value]
+     */
+    protected init(value?: Object): void;
+    /**
+     * Mark parents as expanded so that item is visible
+     * @param {*} value
+     * @returns
+     */
+    ensureVisible(value: any): boolean;
+    /**
+     * Toggle expansion of item
+     * @param {*} value
+     * @returns
+     */
+    toggleExpansion(key: any): boolean;
+    /**
+     * Expand item
+     * @param {*} value
+     * @returns
+     */
+    expand(key: any): boolean;
+    /**
+     * Collapse item
+     * @param {*} value
+     * @returns
+     */
+    collapse(key: any): boolean;
+}
+import { ListController } from './list-controller.svelte';

package/dist/packages/states/src/proxy.svelte.d.ts

@@ -0,0 +1,43 @@
+export class Proxy {
+    constructor(value: any, fields: any);
+    set fields(value: null);
+    get fields(): null;
+    set id(new_id: null);
+    get id(): null;
+    get children(): Proxy[];
+    set value(value: null);
+    get value(): null;
+    /**
+     * Gets a mapped attribute from the original item
+     *
+     * @param {string} fieldName - Name of the field to get
+     * @param {any} defaultValue - Default value to return if not found
+     * @returns {any|undefined} - The attribute value or null if not found
+     */
+    get(fieldName: string, defaultValue: any): any | undefined;
+    /**
+     * Checks if a mapped attribute exists in the original item
+     * @param {string} fieldName - Name of the field to check
+     * @returns boolean
+     */
+    has(fieldName: string): false | (<P extends PropertyKey>(s: P) => boolean);
+    /**
+     * Gets the appropriate snippet for rendering this item:
+     * - Uses the 'snippet' field from the current item to find the snippet key
+     * - Finds a matching snippet in the provided collection using this key
+     * - Falls back to the defaultSnippet if:
+     *   - No snippet key is configured for this item
+     *   - The configured snippet key doesn't exist in the snippets collection
+     * @param {Object} snippets
+     * @param {import('svelte').Snippet|undefined} defaultSnippet
+     * @returns {import('svelte').Snippet|undefined}
+     */
+    getSnippet(snippets: Object, defaultSnippet: import("svelte").Snippet | undefined): import("svelte").Snippet | undefined;
+    /**
+     * Identifies if the item has children
+     */
+    get hasChildren(): boolean;
+    set expanded(value: any);
+    get expanded(): any;
+    #private;
+}

package/dist/packages/states/src/tabular.svelte.d.ts

@@ -0,0 +1,5 @@
+export class TableWrapper {
+    constructor(items: any);
+    data: null;
+    headers: any[];
+}

package/dist/packages/states/src/traversal.svelte.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Handles navigation through a flattened data structure
+ */
+export class Traversal {
+    /**
+     * @param {object} dataProvider - Data provider component
+     */
+    constructor(dataProvider: object);
+    /**
+     * Gets the current focused key
+     * @returns {string|null} The current key or null if none selected
+     */
+    get currentKey(): string | null;
+    /**
+     * Gets the current focused index
+     * @returns {number} The current index or -1 if none selected
+     */
+    get currentIndex(): number;
+    /**
+     * Gets the currently focused item
+     * @returns {object|null} The focused item or null
+     */
+    get focused(): object | null;
+    /**
+     * Calculates the current index based on the current key
+     * @private
+     * @returns {number} The current index or -1 if not found
+     */
+    private getCurrentIndex;
+    /**
+     * Focuses on an item by its key
+     * @param {string} key - Key of the item to focus
+     * @returns {boolean} True if focus changed, false otherwise
+     */
+    moveToKey(key: string): boolean;
+    /**
+     * Focuses on an item by its index in the flattened list
+     * @param {number} index - Index of the item to focus
+     * @returns {boolean} True if focus changed, false otherwise
+     */
+    moveToIndex(index: number): boolean;
+    /**
+     * Focuses on an item by finding its value in the data
+     * @param {*} value - Value to find and focus
+     * @returns {boolean} True if found and focused, false otherwise
+     */
+    moveToValue(value: any): boolean;
+    /**
+     * Moves focus to the previous visible item
+     * @returns {boolean} True if moved, false if at the beginning
+     */
+    movePrev(): boolean;
+    /**
+     * Moves focus to the next visible item
+     * @returns {boolean} True if moved, false if at the end
+     */
+    moveNext(): boolean;
+    /**
+     * Moves focus to the first item
+     * @returns {boolean} True if moved, false otherwise
+     */
+    moveFirst(): boolean;
+    /**
+     * Moves focus to the last item
+     * @returns {boolean} True if moved, false otherwise
+     */
+    moveLast(): boolean;
+    #private;
+}