slim-select 3.6.1 → 4.0.0

package/dist/src/docs/nav.d.ts

@@ -0,0 +1,20 @@
+export interface NavLink {
+    label: string;
+    path: string;
+}
+export interface HeaderItem {
+    id: string;
+    label: string;
+    /** Direct link (no dropdown) */
+    path?: string;
+    /** Dropdown of pages */
+    children?: NavLink[];
+}
+/**
+ * Top header is intentionally short. "Docs" and "Frameworks" open a dropdown of
+ * pages; each page renders its own "On this page" sidebar (see page_nav.vue).
+ */
+export declare const headerItems: HeaderItem[];
+export declare function hasSidebar(path: string): boolean;
+/** Which header item should appear active for the current route. */
+export declare function activeHeaderId(path: string): string | null;

package/dist/store.d.ts

@@ -20,7 +20,6 @@ export declare class Optgroup {
     id: string;
     label: string;
     selectAll: boolean;
-    selectAllText: string;
     closable: 'off' | 'open' | 'close';
     options: Partial<Option>[];
     constructor(optgroup: Partial<Optgroup>);
@@ -29,13 +28,22 @@ export default class Store {
     private selectType;
     private data;
     private selectedOrder;
+    /** Baseline option list — restored when search is cleared (API results are temporary). */
+    private catalog;
     constructor(type: 'single' | 'multiple', data: (Partial<Option> | Partial<Optgroup>)[]);
     validateDataArray(data: (Partial<Option> | Partial<Optgroup>)[]): Error | null;
     validateOption(option: Partial<Option>): Error | null;
     partialToFullData(data: (Partial<Option> | Partial<Optgroup>)[]): (Option | Optgroup)[];
+    /** Snapshot the current data as the catalog baseline (not called for API search results). */
+    snapshotCatalog(): void;
+    /** Catalog baseline used when clearing search. */
+    getCatalogData(): (Option | Optgroup)[];
+    private cloneData;
+    private optionMatchesSelected;
+    private findOptionInData;
     setData(data: (Partial<Option> | Partial<Optgroup>)[], preserveSelected?: boolean): void;
-    getData(): Option[] | Optgroup[];
-    getDataOptions(): Option[];
+    getData(clone?: boolean): Option[] | Optgroup[];
+    getDataOptions(clone?: boolean): Option[];
     addOption(option: Partial<Option>, addToStart?: boolean): void;
     setSelectedBy(selectedType: 'id' | 'value', selectedValues: string[], allowEmptySelection?: boolean): void;
     getSelected(): string[];
@@ -46,8 +54,9 @@ export default class Store {
     getSelectType(): string;
     getFirstOption(): Option | null;
     search(search: string, searchFilter: (opt: Option, search: string) => boolean): (Option | Optgroup)[];
+    private createOptgroupView;
     filter(filter: {
         (opt: Option): boolean;
-    } | null, includeOptgroup: boolean): (Option | Optgroup)[];
+    } | null, includeOptgroup: boolean, clone?: boolean): (Option | Optgroup)[];
     selectedOrderOptions(options: Option[]): Option[];
 }

package/dist/sync.d.ts

@@ -0,0 +1,78 @@
+import { default as Render } from './render';
+import { default as Select } from './select';
+import { default as Store, Optgroup, Option } from './store';
+/** Where a change originated — affects batching and render behavior. */
+export type ChangeSource = 'native' | 'ui' | 'api';
+export interface SyncEvents {
+    afterChange?: (newVal: Option[]) => void;
+    error?: (err: Error) => void;
+}
+/**
+ * A single unit of work in the sync queue.
+ * Structure = replace option list; selection = change selected only; addOption = append one.
+ */
+export type SyncChange = {
+    type: 'structure';
+    data: (Partial<Option> | Partial<Optgroup>)[];
+    source: ChangeSource;
+    /** Keep current selection when replacing data (async search results). */
+    preserveSelection?: boolean;
+    /** API search results — do not update the catalog baseline. */
+    isSearchResult?: boolean;
+} | {
+    type: 'selection';
+    values: string | string[];
+    source: ChangeSource;
+    /** false when Vue/parent is pushing modelValue down (avoid emit loop). */
+    runAfterChange?: boolean;
+} | {
+    type: 'addOption';
+    option: Partial<Option>;
+    source: ChangeSource;
+};
+export interface SyncDeps {
+    select: Select;
+    store: Store;
+    render: Render;
+    events: SyncEvents;
+    search?: (value: string) => void;
+    onError?: (err: Error) => void;
+}
+/** Skip structure sync when incoming data matches what's already in the store. */
+export declare function shouldSkipStructureUpdate(store: Store, data: (Partial<Option> | Partial<Optgroup>)[]): boolean;
+/**
+ * Resolve setSelected() arguments to option ids.
+ * Accepts either ids or values for backward compatibility.
+ */
+export declare function resolveSelectedIds(store: Store, values: string | string[]): string[];
+export default class SyncCoordinator {
+    private deps;
+    private queue;
+    private flushScheduled;
+    /** True while applyChange is running — prevents re-entrant flush loops. */
+    isSyncing: boolean;
+    constructor(deps: SyncDeps);
+    enqueue(change: SyncChange): void;
+    /** Process everything in the queue. Callable from tests for deterministic native sync. */
+    flush(): void;
+    /**
+     * Collapse a batch into the minimum work needed.
+     * Structure sync already includes selection from getData(), so drop redundant
+     * selection changes in the same batch. When multiple structure updates arrive,
+     * only the last one wins.
+     */
+    private coalesceBatch;
+    private applyChange;
+    /**
+     * Full sync: store → native <select> rebuild → render values + options.
+     * Used when the option list itself changes (setData, native DOM edits, search results).
+     */
+    private applyStructure;
+    /**
+     * Lightweight selection sync: flip option.selected on native DOM only.
+     * Avoids select.updateOptions() (innerHTML rebuild) for selection-only changes.
+     */
+    private applySelection;
+    /** Append a single option then full-sync native + render (same as legacy addOption). */
+    private applyAddOption;
+}