juxscript 1.0.132 → 1.1.2

package/lib/componentsv2/list/ListEngine.js

@@ -1,322 +0,0 @@
-import { BaseEngine } from '../base/BaseEngine.js';
-export class ListEngine extends BaseEngine {
-    constructor(id, options = {}) {
-        super(id, options);
-    }
-    /**
-     * OPTIONS CONTRACT
-     * Defines valid options with types, defaults, and aliases for common mistakes.
-     */
-    get optionsSchema() {
-        return {
-            items: {
-                type: 'array',
-                default: [],
-                description: 'Array of list items (strings or objects)',
-                aliases: ['data', 'list', 'values', 'options', 'entries']
-            },
-            listType: {
-                type: 'string',
-                default: 'unordered',
-                description: 'List type: "unordered" (ul) or "ordered" (ol)',
-                aliases: ['type', 'ordered', 'ul', 'ol']
-            },
-            selectionMode: {
-                type: 'string',
-                default: 'none',
-                description: 'Selection mode: "single", "multiple", or "none"',
-                aliases: ['selection', 'mode', 'selectable', 'multiselect']
-            },
-            filterText: {
-                type: 'string',
-                default: '',
-                description: 'Initial filter/search text',
-                aliases: ['filter', 'search', 'query', 'searchText']
-            },
-            sorted: {
-                type: 'string',
-                default: 'none',
-                description: 'Sort order: "asc", "desc", or "none"',
-                aliases: ['sort', 'order', 'sortOrder', 'sortDirection']
-            },
-            noItemsMessage: {
-                type: 'string',
-                default: null,
-                description: 'Message shown when list is empty',
-                aliases: ['emptyMessage', 'emptyText', 'placeholder', 'noItems']
-            },
-            columns: {
-                type: 'array',
-                default: [],
-                description: 'Column definitions for tabular display',
-                aliases: ['cols', 'fields', 'headers']
-            },
-            idField: {
-                type: 'string',
-                default: '_juxId',
-                description: 'Property name to use as item ID',
-                aliases: ['idKey', 'idProperty', 'keyField']
-            }
-        };
-    }
-    /**
-     * CONTRACT IMPLEMENTATION:
-     * Convert loose Options into STRICT initial state.
-     */
-    prepareState(id, options) {
-        const idField = options.idField || '_juxId';
-        return {
-            id,
-            classes: ['jux-list'],
-            visible: true,
-            disabled: false,
-            loading: false,
-            attributes: {},
-            items: (options && Array.isArray(options.items) ? options.items : []).map((input, i) => ListEngine.normalizeItem(input, idField, i)),
-            listType: options.listType || 'unordered',
-            selectionMode: options.selectionMode || 'none',
-            filterText: options.filterText || '',
-            sorted: options.sorted || 'none',
-            noItemsMessage: options.noItemsMessage ?? null,
-            columns: options.columns || [],
-            idField
-        };
-    }
-    // ✅ Normalization Helper (Static to allow usage in prepareState)
-    static normalizeItem(input, idField, index) {
-        const isObj = typeof input === 'object' && input !== null;
-        const fallbackId = `item-${Date.now()}-${index ?? Math.random().toString(36).substr(2, 5)}`;
-        // Extract known props or fallback
-        let text = String(input);
-        if (isObj) {
-            // Prioritize standard fields if they exist, otherwise first string prop?
-            // For now, assume 'text' or 'label' or fallback to stringified
-            text = input.text || input.label || input.title || text;
-        }
-        // ID resolution
-        let id = fallbackId;
-        if (isObj) {
-            id = input[idField] || input.id || fallbackId;
-        }
-        const classes = isObj ? (input.className ? [input.className] : (input.classes || [])) : [];
-        const selected = false;
-        // Merge all props for column access
-        const extraProps = isObj ? { ...input } : { value: input };
-        return {
-            ...extraProps,
-            id: String(id),
-            text,
-            selected,
-            classes
-        };
-    }
-    // --- State-Aligned Methods ---
-    /**
-     * Set items array
-     * Method name matches state property: items
-     */
-    items(value) {
-        const normalized = value.map((input, i) => ListEngine.normalizeItem(input, this.state.idField, i));
-        this.updateState({ items: normalized });
-        this.emit('items', { items: normalized });
-        return this;
-    }
-    /**
-     * Set list type
-     * Method name matches state property: listType
-     */
-    listType(type) {
-        if (this.state.listType !== type) {
-            this.updateState({ listType: type });
-            this.emit('layout', { type });
-        }
-        return this;
-    }
-    /**
-     * Set selection mode
-     * Method name matches state property: selectionMode
-     */
-    selectionMode(mode) {
-        this.updateState({ selectionMode: mode });
-        this.emit('selectionConfig', { mode });
-        return this;
-    }
-    /**
-     * Set filter text
-     * Method name matches state property: filterText
-     */
-    filterText(text) {
-        this.updateState({ filterText: text });
-        this.emit('filter', { text });
-        return this;
-    }
-    /**
-     * Set sort order
-     * Method name matches state property: sorted
-     */
-    sorted(order) {
-        let sortedItems = [...this.state.items];
-        if (order !== 'none') {
-            sortedItems.sort((a, b) => {
-                const textA = a.text.toLowerCase();
-                const textB = b.text.toLowerCase();
-                if (textA < textB)
-                    return order === 'asc' ? -1 : 1;
-                if (textA > textB)
-                    return order === 'asc' ? 1 : -1;
-                return 0;
-            });
-        }
-        this.updateState({ sorted: order, items: sortedItems });
-        this.emit('sort', { order });
-        return this;
-    }
-    /**
-     * Set no items message
-     * Method name matches state property: noItemsMessage
-     */
-    noItemsMessage(message) {
-        this.updateState({ noItemsMessage: message });
-        this.emit('config:noItems', { message });
-        return this;
-    }
-    /**
-     * Set columns configuration
-     * Method name matches state property: columns
-     */
-    columns(cols) {
-        this.updateState({ columns: cols });
-        this.emit('config:columns', { columns: cols });
-        return this;
-    }
-    // --- Convenience Aliases ---
-    /** @alias for selectionMode() */
-    setSelectionMode(mode) {
-        return this.selectionMode(mode);
-    }
-    /** @alias for columns() */
-    setColumns(cols) {
-        return this.columns(cols);
-    }
-    /** @alias for filterText() */
-    filter(text) {
-        return this.filterText(text);
-    }
-    /** @alias for noItemsMessage() */
-    enableNoItems(message = 'No items found.') {
-        return this.noItemsMessage(message);
-    }
-    /**
-     * Toggle sort order (cycles: none -> asc -> desc -> none)
-     * @alias Convenience method that cycles sorted state
-     */
-    toggleSort(order) {
-        if (order) {
-            return this.sorted(order);
-        }
-        const current = this.state.sorted;
-        const next = current === 'none' ? 'asc' : (current === 'asc' ? 'desc' : 'none');
-        return this.sorted(next);
-    }
-    /**
-     * Toggle list type between ordered/unordered
-     * @alias Convenience method that toggles listType state
-     */
-    toggleListType() {
-        const next = this.state.listType === 'unordered' ? 'ordered' : 'unordered';
-        return this.listType(next);
-    }
-    addItem(input) {
-        const newItem = ListEngine.normalizeItem(input, this.state.idField);
-        this.updateState({ items: [...this.state.items, newItem] });
-        this.emit('add', { item: newItem });
-        return this;
-    }
-    addItems(items) {
-        const newItems = items.map((input, i) => ListEngine.normalizeItem(input, this.state.idField, i));
-        this.updateState({ items: [...this.state.items, ...newItems] });
-        this.emit('addItems', { items: newItems });
-        return this;
-    }
-    clearItems() {
-        const count = this.state.items.length;
-        if (count > 0) {
-            this.updateState({ items: [] });
-            this.emit('clear', { count });
-        }
-        return this;
-    }
-    // ✅ Modified: Accepts ID string OR Index
-    removeItem(identifier) {
-        let index = -1;
-        if (typeof identifier === 'number') {
-            index = identifier;
-        }
-        else {
-            // Find by ID string
-            index = this.state.items.findIndex(i => String(i.id) === String(identifier));
-        }
-        if (index < 0 || index >= this.state.items.length) {
-            // console.warn(`Jux List: removeItem item not found (${identifier})`);
-            return this;
-        }
-        const itemToRemove = this.state.items[index];
-        const newItems = this.state.items.filter((_, i) => i !== index);
-        this.updateState({ items: newItems });
-        this.emit('remove', { item: itemToRemove, index });
-        return this;
-    }
-    updateItem(index, updates) {
-        const items = [...this.state.items];
-        if (index < 0 || index >= items.length) {
-            console.warn(`Jux List: updateItem index ${index} out of bounds.`);
-            return this;
-        }
-        const currentItem = items[index];
-        const changes = typeof updates === 'string' ? { text: updates } : updates;
-        items[index] = { ...currentItem, ...changes };
-        this.updateState({ items });
-        this.emit('update', { item: items[index], changes, index });
-        return this;
-    }
-    moveItem(fromIndex, toIndex) {
-        const items = [...this.state.items];
-        // Bounds check
-        if (fromIndex < 0 || fromIndex >= items.length || toIndex < 0 || toIndex >= items.length) {
-            console.warn(`Jux List: moveItem indices out of bounds (${fromIndex} -> ${toIndex}).`);
-            return this;
-        }
-        const movingItem = items[fromIndex];
-        const [movedItem] = items.splice(fromIndex, 1);
-        items.splice(toIndex, 0, movedItem);
-        this.updateState({ items });
-        this.emit('move', { item: movingItem, from: fromIndex, to: toIndex });
-        return this;
-    }
-    toggleSelection(index) {
-        const mode = this.state.selectionMode;
-        if (mode === 'none')
-            return this;
-        const items = [...this.state.items];
-        if (index < 0 || index >= items.length)
-            return this;
-        if (mode === 'multiple') {
-            items[index] = { ...items[index], selected: !items[index].selected };
-        }
-        else {
-            const willBeSelected = !items[index].selected;
-            for (let i = 0; i < items.length; i++) {
-                if (i === index) {
-                    items[i] = { ...items[i], selected: willBeSelected };
-                }
-                else if (willBeSelected && items[i].selected) {
-                    items[i] = { ...items[i], selected: false };
-                }
-            }
-        }
-        this.updateState({ items });
-        this.emit('select', { item: items[index], index, selected: items[index].selected });
-        return this;
-    }
-}
-//# sourceMappingURL=ListEngine.js.map

package/lib/componentsv2/list/ListSkin.d.ts

@@ -1,20 +0,0 @@
-import { BaseSkin } from '../base/BaseSkin.js';
-import { ListEngine, ListState } from './ListEngine.js';
-export declare class ListSkin extends BaseSkin<ListState, ListEngine> {
-    #private;
-    constructor(engine: ListEngine);
-    enableSearch(enabled: boolean): void;
-    enableAdd(enabled: boolean): void;
-    enableDelete(enabled: boolean): void;
-    enableMove(enabled: boolean): void;
-    enableSort(enabled: boolean): void;
-    enableNoItems(message?: string): void;
-    enableEdit(enabled: boolean): void;
-    protected get structureCss(): string;
-    protected bindEvents(root: HTMLElement): void;
-    /**
-     * Skin Contract: Update/Changes
-     */
-    protected updateSkin(state: ListState): void;
-}
-//# sourceMappingURL=ListSkin.d.ts.map