slim-select 2.2.0 → 2.2.1

package/src/vue/dist/slim-select/render.d.ts

@@ -0,0 +1,116 @@
+import Settings from './settings';
+import Store, { DataArray, Option, OptionOptional } from './store';
+export interface Callbacks {
+    open: () => void;
+    close: () => void;
+    addable?: (value: string) => Promise<OptionOptional | string> | OptionOptional | string;
+    setSelected: (value: string[]) => void;
+    addOption: (option: Option) => void;
+    search: (search: string) => void;
+    beforeChange?: (newVal: Option[], oldVal: Option[]) => boolean | void;
+    afterChange?: (newVal: Option[]) => void;
+}
+export interface Main {
+    main: HTMLDivElement;
+    values: HTMLDivElement;
+    deselect: {
+        main: HTMLDivElement;
+        svg: SVGSVGElement;
+        path: SVGPathElement;
+    };
+    arrow: {
+        main: SVGSVGElement;
+        path: SVGPathElement;
+    };
+}
+export interface Content {
+    main: HTMLDivElement;
+    search: Search;
+    list: HTMLDivElement;
+}
+export interface Search {
+    main: HTMLDivElement;
+    input: HTMLInputElement;
+    addable?: {
+        main: HTMLDivElement;
+        svg: SVGSVGElement;
+        path: SVGPathElement;
+    };
+}
+export default class Render {
+    settings: Settings;
+    store: Store;
+    callbacks: Callbacks;
+    main: Main;
+    content: Content;
+    classes: {
+        main: string;
+        placeholder: string;
+        values: string;
+        single: string;
+        value: string;
+        valueText: string;
+        valueDelete: string;
+        valueOut: string;
+        deselect: string;
+        deselectPath: string;
+        arrow: string;
+        arrowClose: string;
+        arrowOpen: string;
+        content: string;
+        openAbove: string;
+        openBelow: string;
+        search: string;
+        searchHighlighter: string;
+        searching: string;
+        addable: string;
+        addablePath: string;
+        list: string;
+        optgroup: string;
+        optgroupLabel: string;
+        optgroupLabelText: string;
+        optgroupActions: string;
+        optgroupSelectAll: string;
+        optgroupSelectAllBox: string;
+        optgroupSelectAllCheck: string;
+        optgroupClosable: string;
+        option: string;
+        optionDelete: string;
+        highlighted: string;
+        open: string;
+        close: string;
+        selected: string;
+        error: string;
+        disabled: string;
+        hide: string;
+    };
+    constructor(settings: Required<Settings>, store: Store, callbacks: Callbacks);
+    enable(): void;
+    disable(): void;
+    open(): void;
+    close(): void;
+    mainDiv(): Main;
+    mainFocus(trigger: boolean): void;
+    placeholder(): HTMLDivElement;
+    renderValues(): void;
+    private renderSingleValue;
+    private renderMultipleValues;
+    multipleValue(option: Option): HTMLDivElement;
+    contentDiv(): Content;
+    moveContent(): void;
+    searchDiv(): Search;
+    searchFocus(trigger: boolean): void;
+    getOptions(notPlaceholder?: boolean, notDisabled?: boolean, notHidden?: boolean): HTMLDivElement[];
+    highlight(dir: 'up' | 'down'): void;
+    listDiv(): HTMLDivElement;
+    renderError(error: string): void;
+    renderSearching(): void;
+    renderOptions(data: DataArray): void;
+    option(option: Option): HTMLDivElement;
+    destroy(): void;
+    private highlightText;
+    moveContentAbove(): void;
+    moveContentBelow(): void;
+    ensureElementInView(container: HTMLElement, element: HTMLElement): void;
+    putContent(el: HTMLElement, isOpen: boolean): 'up' | 'down';
+}

package/src/vue/dist/slim-select/select.d.ts

@@ -0,0 +1,33 @@
+import { DataArray, DataArrayPartial, Optgroup, OptgroupOptional, Option } from './store';
+export default class Select {
+    select: HTMLSelectElement;
+    listen: boolean;
+    onSelectChange?: (data: DataArrayPartial) => void;
+    onValueChange?: (value: string[]) => void;
+    private observer;
+    constructor(select: HTMLSelectElement);
+    enable(): void;
+    disable(): void;
+    hideUI(): void;
+    showUI(): void;
+    changeListen(on: boolean): void;
+    addSelectChangeListener(func: (data: DataArrayPartial) => void): void;
+    removeSelectChangeListener(): void;
+    addValueChangeListener(func: (value: string[]) => void): void;
+    removeValueChangeListener(): void;
+    valueChange(ev: Event): any;
+    private observeWrapper;
+    private addObserver;
+    private connectObserver;
+    private disconnectObserver;
+    getData(): DataArrayPartial;
+    getDataFromOptgroup(optgroup: HTMLOptGroupElement): OptgroupOptional;
+    getDataFromOption(option: HTMLOptionElement): Option;
+    getSelectedValues(): string[];
+    setSelected(value: string[]): void;
+    updateSelect(id?: string, style?: string, classes?: string[]): void;
+    updateOptions(data: DataArray): void;
+    createOptgroup(optgroup: Optgroup): HTMLOptGroupElement;
+    createOption(info: Option): HTMLOptionElement;
+    destroy(): void;
+}

package/src/vue/dist/slim-select/settings.d.ts

@@ -0,0 +1,30 @@
+/// <reference types="node" />
+export type SettingsPartial = Partial<Settings>;
+export default class Settings {
+    id: string;
+    style: string;
+    class: string[];
+    isMultiple: boolean;
+    isOpen: boolean;
+    triggerFocus: boolean;
+    intervalMove: NodeJS.Timeout | null;
+    isEnabled: boolean;
+    alwaysOpen: boolean;
+    showSearch: boolean;
+    searchPlaceholder: string;
+    searchText: string;
+    searchingText: string;
+    searchHighlight: boolean;
+    closeOnSelect: boolean;
+    contentLocation: HTMLElement;
+    contentPosition: 'relative' | 'absolute';
+    openPosition: 'auto' | 'up' | 'down';
+    placeholderText: string;
+    allowDeselect: boolean;
+    hideSelected: boolean;
+    showOptionTooltips: boolean;
+    minSelected: number;
+    maxSelected: number;
+    timeoutDelay: number;
+    constructor(settings?: SettingsPartial);
+}

package/src/vue/dist/slim-select/store.d.ts

@@ -0,0 +1,76 @@
+export type DataArray = DataObject[];
+export type DataObject = Optgroup | Option;
+export type DataArrayPartial = DataObjectPartial[];
+export type DataObjectPartial = OptgroupOptional | OptionOptional;
+type selectType = 'single' | 'multiple';
+export interface OptgroupOptional {
+    id?: string;
+    label: string;
+    selectAll?: boolean;
+    closable?: 'off' | 'open' | 'close';
+    options?: OptionOptional[];
+}
+export declare class Optgroup {
+    id: string;
+    label: string;
+    selectAll: boolean;
+    closable: 'off' | 'open' | 'close';
+    options: Option[];
+    constructor(optgroup: OptgroupOptional);
+}
+export interface OptionOptional {
+    id?: string;
+    value?: string;
+    text: string;
+    html?: string;
+    selected?: boolean;
+    display?: boolean;
+    disabled?: boolean;
+    mandatory?: boolean;
+    placeholder?: boolean;
+    class?: string;
+    style?: string;
+    data?: {
+        [key: string]: string;
+    };
+}
+export declare class Option {
+    id: string;
+    value: string;
+    text: string;
+    html: string;
+    selected: boolean;
+    display: boolean;
+    disabled: boolean;
+    placeholder: boolean;
+    class: string;
+    style: string;
+    data: {
+        [key: string]: string;
+    };
+    mandatory: boolean;
+    constructor(option: OptionOptional);
+}
+export default class Store {
+    private selectType;
+    private data;
+    constructor(type: selectType, data: DataArrayPartial);
+    validateDataArray(data: DataArray | DataArrayPartial): Error | null;
+    validateOption(option: Option | OptionOptional): Error | null;
+    partialToFullData(data: DataArrayPartial): DataArray;
+    setData(data: DataArray | DataArrayPartial): void;
+    getData(): DataArray;
+    getDataOptions(): Option[];
+    addOption(option: OptionOptional): void;
+    setSelectedBy(selectedType: 'id' | 'value', selectedValues: string[]): void;
+    getSelected(): string[];
+    getSelectedOptions(): Option[];
+    getSelectedIDs(): string[];
+    getOptgroupByID(id: string): Optgroup | null;
+    getOptionByID(id: string): Option | null;
+    search(search: string, searchFilter: (opt: Option, search: string) => boolean): DataArray;
+    filter(filter: {
+        (opt: Option): boolean;
+    } | null, includeOptgroup: boolean): DataArray;
+}
+export {};

package/src/vue/dist/slimselectvue.es.js

@@ -944,7 +944,11 @@ class Render {
                     const optgroupClosableArrow = document.createElementNS('http://www.w3.org/2000/svg', 'path');
                     optgroupClosableArrow.setAttribute('d', this.classes.arrow);
                     optgroupClosableSvg.appendChild(optgroupClosableArrow);
-                    if (d.closable === 'open') {
+                    if (d.options.some((o) => o.selected)) {
+                        optgroupClosable.classList.add(this.classes.open);
+                        optgroupClosableArrow.setAttribute('d', this.classes.arrowOpen);
+                    }
+                    else if (d.closable === 'open') {
                         optgroupEl.classList.add(this.classes.open);
                         optgroupClosableArrow.setAttribute('d', this.classes.arrowOpen);
                     }

package/src/vue/dist/slimselectvue.global.js

@@ -945,7 +945,11 @@ var SlimSelectVue = (function (vue) {
                       const optgroupClosableArrow = document.createElementNS('http://www.w3.org/2000/svg', 'path');
                       optgroupClosableArrow.setAttribute('d', this.classes.arrow);
                       optgroupClosableSvg.appendChild(optgroupClosableArrow);
-                      if (d.closable === 'open') {
+                      if (d.options.some((o) => o.selected)) {
+                          optgroupClosable.classList.add(this.classes.open);
+                          optgroupClosableArrow.setAttribute('d', this.classes.arrowOpen);
+                      }
+                      else if (d.closable === 'open') {
                           optgroupEl.classList.add(this.classes.open);
                           optgroupClosableArrow.setAttribute('d', this.classes.arrowOpen);
                       }

package/src/vue/dist/slimselectvue.ssr.js

@@ -946,7 +946,11 @@ class Render {
                     const optgroupClosableArrow = document.createElementNS('http://www.w3.org/2000/svg', 'path');
                     optgroupClosableArrow.setAttribute('d', this.classes.arrow);
                     optgroupClosableSvg.appendChild(optgroupClosableArrow);
-                    if (d.closable === 'open') {
+                    if (d.options.some((o) => o.selected)) {
+                        optgroupClosable.classList.add(this.classes.open);
+                        optgroupClosableArrow.setAttribute('d', this.classes.arrowOpen);
+                    }
+                    else if (d.closable === 'open') {
                         optgroupEl.classList.add(this.classes.open);
                         optgroupClosableArrow.setAttribute('d', this.classes.arrowOpen);
                     }

package/src/vue/dist/vue/hello.d.ts

@@ -0,0 +1,2 @@
+declare const hello = "hello world";
+export default hello;

package/src/vue/dist/vue/slimselect.vue.d.ts

@@ -0,0 +1,286 @@
+/// <reference types="node" />
+import { PropType } from 'vue';
+import SlimSelect, { Events } from '../slim-select';
+import Settings from '../slim-select/settings';
+import { DataArrayPartial } from '../slim-select/store';
+declare const _default: import("vue").DefineComponent<{
+    data: {
+        type: PropType<DataArrayPartial>;
+    };
+    settings: {
+        type: PropType<Settings>;
+    };
+    events: {
+        type: PropType<Events>;
+    };
+}, unknown, {
+    slim: SlimSelect | null;
+}, {}, {
+    getSlimSelect(): {
+        selectEl: HTMLSelectElement;
+        settings: {
+            id: string;
+            style: string;
+            class: string[];
+            isMultiple: boolean;
+            isOpen: boolean;
+            triggerFocus: boolean;
+            intervalMove: {
+                hasRef: () => boolean;
+                refresh: () => NodeJS.Timeout;
+                [Symbol.toPrimitive]: () => number;
+                ref: () => NodeJS.Timeout;
+                unref: () => NodeJS.Timeout;
+            } | null;
+            isEnabled: boolean;
+            alwaysOpen: boolean;
+            showSearch: boolean;
+            searchPlaceholder: string;
+            searchText: string;
+            searchingText: string;
+            searchHighlight: boolean;
+            closeOnSelect: boolean;
+            contentLocation: HTMLElement;
+            contentPosition: "relative" | "absolute";
+            openPosition: "auto" | "up" | "down";
+            placeholderText: string;
+            allowDeselect: boolean;
+            hideSelected: boolean;
+            showOptionTooltips: boolean;
+            minSelected: number;
+            maxSelected: number;
+            timeoutDelay: number;
+        };
+        select: {
+            select: HTMLSelectElement;
+            listen: boolean;
+            onSelectChange?: ((data: DataArrayPartial) => void) | undefined;
+            onValueChange?: ((value: string[]) => void) | undefined;
+            enable: () => void;
+            disable: () => void;
+            hideUI: () => void;
+            showUI: () => void;
+            changeListen: (on: boolean) => void;
+            addSelectChangeListener: (func: (data: DataArrayPartial) => void) => void;
+            removeSelectChangeListener: () => void;
+            addValueChangeListener: (func: (value: string[]) => void) => void;
+            removeValueChangeListener: () => void;
+            valueChange: (ev: Event) => any;
+            getData: () => DataArrayPartial;
+            getDataFromOptgroup: (optgroup: HTMLOptGroupElement) => import("../slim-select/store").OptgroupOptional;
+            getDataFromOption: (option: HTMLOptionElement) => import("../slim-select/store").Option;
+            getSelectedValues: () => string[];
+            setSelected: (value: string[]) => void;
+            updateSelect: (id?: string | undefined, style?: string | undefined, classes?: string[] | undefined) => void;
+            updateOptions: (data: import("../slim-select/store").DataArray) => void;
+            createOptgroup: (optgroup: import("../slim-select/store").Optgroup) => HTMLOptGroupElement;
+            createOption: (info: import("../slim-select/store").Option) => HTMLOptionElement;
+            destroy: () => void;
+        };
+        store: {
+            validateDataArray: (data: DataArrayPartial | import("../slim-select/store").DataArray) => Error | null;
+            validateOption: (option: import("../slim-select/store").OptionOptional | import("../slim-select/store").Option) => Error | null;
+            partialToFullData: (data: DataArrayPartial) => import("../slim-select/store").DataArray;
+            setData: (data: DataArrayPartial | import("../slim-select/store").DataArray) => void;
+            getData: () => import("../slim-select/store").DataArray;
+            getDataOptions: () => import("../slim-select/store").Option[];
+            addOption: (option: import("../slim-select/store").OptionOptional) => void;
+            setSelectedBy: (selectedType: "value" | "id", selectedValues: string[]) => void;
+            getSelected: () => string[];
+            getSelectedOptions: () => import("../slim-select/store").Option[];
+            getSelectedIDs: () => string[];
+            getOptgroupByID: (id: string) => import("../slim-select/store").Optgroup | null;
+            getOptionByID: (id: string) => import("../slim-select/store").Option | null;
+            search: (search: string, searchFilter: (opt: import("../slim-select/store").Option, search: string) => boolean) => import("../slim-select/store").DataArray;
+            filter: (filter: ((opt: import("../slim-select/store").Option) => boolean) | null, includeOptgroup: boolean) => import("../slim-select/store").DataArray;
+        };
+        render: {
+            settings: {
+                id: string;
+                style: string;
+                class: string[];
+                isMultiple: boolean;
+                isOpen: boolean;
+                triggerFocus: boolean;
+                intervalMove: {
+                    hasRef: () => boolean;
+                    refresh: () => NodeJS.Timeout;
+                    [Symbol.toPrimitive]: () => number;
+                    ref: () => NodeJS.Timeout;
+                    unref: () => NodeJS.Timeout;
+                } | null;
+                isEnabled: boolean;
+                alwaysOpen: boolean;
+                showSearch: boolean;
+                searchPlaceholder: string;
+                searchText: string;
+                searchingText: string;
+                searchHighlight: boolean;
+                closeOnSelect: boolean;
+                contentLocation: HTMLElement;
+                contentPosition: "relative" | "absolute";
+                openPosition: "auto" | "up" | "down";
+                placeholderText: string;
+                allowDeselect: boolean;
+                hideSelected: boolean;
+                showOptionTooltips: boolean;
+                minSelected: number;
+                maxSelected: number;
+                timeoutDelay: number;
+            };
+            store: {
+                validateDataArray: (data: DataArrayPartial | import("../slim-select/store").DataArray) => Error | null;
+                validateOption: (option: import("../slim-select/store").OptionOptional | import("../slim-select/store").Option) => Error | null;
+                partialToFullData: (data: DataArrayPartial) => import("../slim-select/store").DataArray;
+                setData: (data: DataArrayPartial | import("../slim-select/store").DataArray) => void;
+                getData: () => import("../slim-select/store").DataArray;
+                getDataOptions: () => import("../slim-select/store").Option[];
+                addOption: (option: import("../slim-select/store").OptionOptional) => void;
+                setSelectedBy: (selectedType: "value" | "id", selectedValues: string[]) => void;
+                getSelected: () => string[];
+                getSelectedOptions: () => import("../slim-select/store").Option[];
+                getSelectedIDs: () => string[];
+                getOptgroupByID: (id: string) => import("../slim-select/store").Optgroup | null;
+                getOptionByID: (id: string) => import("../slim-select/store").Option | null;
+                search: (search: string, searchFilter: (opt: import("../slim-select/store").Option, search: string) => boolean) => import("../slim-select/store").DataArray;
+                filter: (filter: ((opt: import("../slim-select/store").Option) => boolean) | null, includeOptgroup: boolean) => import("../slim-select/store").DataArray;
+            };
+            callbacks: {
+                open: () => void;
+                close: () => void;
+                addable?: ((value: string) => string | import("../slim-select/store").OptionOptional | Promise<string | import("../slim-select/store").OptionOptional>) | undefined;
+                setSelected: (value: string[]) => void;
+                addOption: (option: import("../slim-select/store").Option) => void;
+                search: (search: string) => void;
+                beforeChange?: ((newVal: import("../slim-select/store").Option[], oldVal: import("../slim-select/store").Option[]) => boolean | void) | undefined;
+                afterChange?: ((newVal: import("../slim-select/store").Option[]) => void) | undefined;
+            };
+            main: {
+                main: HTMLDivElement;
+                values: HTMLDivElement;
+                deselect: {
+                    main: HTMLDivElement;
+                    svg: SVGSVGElement;
+                    path: SVGPathElement;
+                };
+                arrow: {
+                    main: SVGSVGElement;
+                    path: SVGPathElement;
+                };
+            };
+            content: {
+                main: HTMLDivElement;
+                search: {
+                    main: HTMLDivElement;
+                    input: HTMLInputElement;
+                    addable?: {
+                        main: HTMLDivElement;
+                        svg: SVGSVGElement;
+                        path: SVGPathElement;
+                    } | undefined;
+                };
+                list: HTMLDivElement;
+            };
+            classes: {
+                main: string;
+                placeholder: string;
+                values: string;
+                single: string;
+                value: string;
+                valueText: string;
+                valueDelete: string;
+                valueOut: string;
+                deselect: string;
+                deselectPath: string;
+                arrow: string;
+                arrowClose: string;
+                arrowOpen: string;
+                content: string;
+                openAbove: string;
+                openBelow: string;
+                search: string;
+                searchHighlighter: string;
+                searching: string;
+                addable: string;
+                addablePath: string;
+                list: string;
+                optgroup: string;
+                optgroupLabel: string;
+                optgroupLabelText: string;
+                optgroupActions: string;
+                optgroupSelectAll: string;
+                optgroupSelectAllBox: string;
+                optgroupSelectAllCheck: string;
+                optgroupClosable: string;
+                option: string;
+                optionDelete: string;
+                highlighted: string;
+                open: string;
+                close: string;
+                selected: string;
+                error: string;
+                disabled: string;
+                hide: string;
+            };
+            enable: () => void;
+            disable: () => void;
+            open: () => void;
+            close: () => void;
+            mainDiv: () => import("../slim-select/render").Main;
+            mainFocus: (trigger: boolean) => void;
+            placeholder: () => HTMLDivElement;
+            renderValues: () => void;
+            multipleValue: (option: import("../slim-select/store").Option) => HTMLDivElement;
+            contentDiv: () => import("../slim-select/render").Content;
+            moveContent: () => void;
+            searchDiv: () => import("../slim-select/render").Search;
+            searchFocus: (trigger: boolean) => void;
+            getOptions: (notPlaceholder?: boolean, notDisabled?: boolean, notHidden?: boolean) => HTMLDivElement[];
+            highlight: (dir: "up" | "down") => void;
+            listDiv: () => HTMLDivElement;
+            renderError: (error: string) => void;
+            renderSearching: () => void;
+            renderOptions: (data: import("../slim-select/store").DataArray) => void;
+            option: (option: import("../slim-select/store").Option) => HTMLDivElement;
+            destroy: () => void;
+            moveContentAbove: () => void;
+            moveContentBelow: () => void;
+            ensureElementInView: (container: HTMLElement, element: HTMLElement) => void;
+            putContent: (el: HTMLElement, isOpen: boolean) => "up" | "down";
+        };
+        events: {
+            search?: ((searchValue: string, currentData: import("../slim-select/store").DataArray) => DataArrayPartial | Promise<DataArrayPartial>) | undefined;
+            searchFilter?: ((option: import("../slim-select/store").Option, search: string) => boolean) | undefined;
+            addable?: ((value: string) => string | import("../slim-select/store").OptionOptional | Promise<string | import("../slim-select/store").OptionOptional>) | undefined;
+            beforeChange?: ((newVal: import("../slim-select/store").Option[], oldVal: import("../slim-select/store").Option[]) => boolean | void) | undefined;
+            afterChange?: ((newVal: import("../slim-select/store").Option[]) => void) | undefined;
+            beforeOpen?: (() => void) | undefined;
+            afterOpen?: (() => void) | undefined;
+            beforeClose?: (() => void) | undefined;
+            afterClose?: (() => void) | undefined;
+            error?: ((err: Error) => void) | undefined;
+        };
+        enable: () => void;
+        disable: () => void;
+        getData: () => import("../slim-select/store").DataArray;
+        setData: (data: DataArrayPartial) => void;
+        getSelected: () => string[];
+        setSelected: (value: string | string[]) => void;
+        addOption: (option: import("../slim-select/store").OptionOptional) => void;
+        open: () => void;
+        close: () => void;
+        search: (value: string) => void;
+        destroy: () => void;
+    } | null;
+}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    data: {
+        type: PropType<DataArrayPartial>;
+    };
+    settings: {
+        type: PropType<Settings>;
+    };
+    events: {
+        type: PropType<Events>;
+    };
+}>>, {}>;
+export default _default;