@lemonadejs/dropdown 2.0.0 → 3.0.4

package/dist/index.d.ts

@@ -0,0 +1,156 @@
+interface DropdownItem {
+    /** Value of the selected item. */
+    value?: string | number;
+    /** Description of the item */
+    text?: string;
+    /** Icon of the item */
+    image?: string;
+    /** Name of the group where the item belongs to */
+    group?: string;
+    /** Keywords to help finding one item */
+    synonym?: string[];
+    /** Item is disabled */
+    disabled?: boolean;
+    /** Color for the item */
+    color?: string;
+}
+
+interface DropdownOptions {
+    /** Preloaded data items for the dropdown */
+    data?: DropdownItem[];
+    /** Format type of the data, typically { id: name } or { value: text } */
+    format?: number;
+    /** Indicates if multiple item selection is allowed */
+    multiple?: boolean;
+    /** Enables the autocomplete feature for user input */
+    autocomplete?: boolean;
+    /** Rendering style of the dropdown: 'default', 'picker', or 'searchbar' */
+    type?: 'default' | 'picker' | 'searchbar',
+    /** Defines the dropdown's width */
+    width?: number;
+    /** Determines if the dropdown is opened when initialized */
+    opened?: boolean;
+    /** The initial value of the dropdown */
+    value?: string;
+    /** Placeholder text for the dropdown */
+    placeholder?: string;
+    /** Allows the user to add new options */
+    newOptions?: boolean;
+    /** Internal controller for the dropdown's position */
+    position?: boolean;
+    /** Event handler for value changes */
+    onchange?: (el: HTMLElement, obj: Dropdown, oldValue: string, newValue: string) => void;
+    /** Event handler for when the dropdown is ready */
+    onload?: (el: HTMLElement, obj: Dropdown, data: any, val: any) => void;
+    /** Event handler for when the dropdown opens */
+    onopen?: (el: HTMLElement) => void;
+    /** Event handler for when the dropdown closes */
+    onclose?: (el: HTMLElement) => void;
+    /** Event handler for when the dropdown receives focus */
+    onfocus?: (el: HTMLElement) => void;
+    /** Event handler for when the dropdown loses focus */
+    onblur?: (el: HTMLElement) => void;
+    /** Event handler for when a new option is added to the dropdown */
+    oninsert?: (obj: Dropdown, item: DropdownItem, newItem: DropdownItem) => void;
+    /** Event handler for just before a new option is added to the dropdown */
+    onbeforeinsert?: (obj: Dropdown, item: DropdownItem) => void;
+    /** Event handler for before a search on autocomplete is performed */
+    onbeforesearch?: (obj: Dropdown, ajaxRequest: object) => boolean | null;
+    /** Event handler for processing search results */
+    onsearch?: (obj: Dropdown, result: object) => void;
+    /** Toggles the sorting of dropdown elements */
+    sortResults?: boolean;
+    /** Indicates if the dropdown should automatically receive focus upon creation */
+    autofocus?: boolean;
+}
+
+interface ItemContainer {
+    /** Data for the item */
+    data: DropdownItem;
+    /** HTML container for the element */
+    element: HTMLElement;
+    /** HTML container for the group */
+    group: HTMLElement;
+}
+
+/** Toast Plugin */
+export type Dropdown = (el: HTMLElement, options: DropdownOptions) => {
+    /** Add a new item to the dropdown */
+    add: (title: string, id: string|number) => DropdownItem;
+    /** Append new data to the dropdown */
+    appendData: (data: DropdownItem[]) => void
+    /** Close the dropdown picker */
+    closeItem: (ignoreEvents?: boolean) => void
+    /** Current selectIndex */
+    currentIndex: number;
+    /** Find the items with the keyword */
+    find: (str: string) => void;
+    /** Select the first item */
+    first: () => void;
+    /** Get all data */
+    getData: () => DropdownItem[];
+    /** Get the index position of a item by its value */
+    getPosition: (value: string) => number | boolean;
+    /** Get the text from the selected options */
+    getText: (asArray?: boolean) => string | string[];
+    /** Get the URL source for the data if defined */
+    getUrl: () => string;
+    /** Get the value from the selected options */
+    getValue: (asArray?: boolean) => string | string[];
+    /** DOM Elements for the groups */
+    groups: HTMLElement[];
+    /** DOM Element for the header */
+    header: HTMLElement;
+    /** Items */
+    items: ItemContainer[];
+    /** Move index to the last element in the dropdown */
+    last: () => void;
+    /** Internal lazy loading method */
+    loadDown: () => void;
+    /** Internal lazy loading method */
+    loadFirst: () => void;
+    /** Internal lazy loading method */
+    loadLast: () => void;
+    /** Internal lazy loading method */
+    loadUp: () => void;
+    /** Move index to the next element in the dropdown */
+    next: () => void;
+    /** Open the dropdown */
+    open: () => void;
+    /** Dropdown configuration */
+    options: DropdownOptions;
+    /** Move index to the previous element in the dropdown */
+    prev: () => void;
+    /** Reset the value of the dropdown */
+    reset: () => void;
+    /** Alias for setCursor */
+    resetCursor: (index: number, setPosition?: boolean) => void
+    /** Set the value to null */
+    resetSelected: () => void;
+    /** Array of results when filtering */
+    results: DropdownItem[];
+    /** Search term */
+    search: string;
+    /** Select an index */
+    selectIndex: (index: number, force?: boolean) => void
+    /** Select an item */
+    selectItem: (item: DropdownItem) => void;
+    /** Set the cursor to a specified element index */
+    setCursor: (index: number, setPosition?: boolean) => void
+    /** Set new data for the dropdown */
+    setData: (items: DropdownItem[]) => void;
+    /** Set the id or value for one item */
+    setId: (item: number|DropdownItem, newId: number) => void;
+    /** Change the dropdown options */
+    setOptions: (newOptions: DropdownOptions, reset?: boolean) => void;
+    /** Change the dropdown data from a URL */
+    setUrl: (newUrl: string, callback?: Function) => void;
+    /** Set the value for a dropdown */
+    setValue: (newValue: string | string[]) => void;
+    /** Internal type */
+    type: 'dropdown';
+    /** Alias for setCursor */
+    updateCursor: (index: number, setPosition?: boolean) => void;
+    /** Current internal value */
+    value: Record<number, string>;
+}

package/dist/index.js

@@ -1,44 +1,333 @@
-;(function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
-    typeof define === 'function' && define.amd ? define(factory) :
-    global.Dropdown = factory();
-}(this, (function () {
-
-    // Load lemonadejs
-    if (typeof(lemonade) == 'undefined') {
-        if (typeof(require) === 'function') {
-            var lemonade = require('lemonadejs');
-        } else if (window.lemonade) {
-            var lemonade = window.lemonade;
-        }
-    }
-
-    // Load lemonadejs
-    if (typeof(jSuites) == 'undefined') {
-        if (typeof(require) === 'function') {
-            var jSuites = require('jsuites');
-        } else if (window.jSuites) {
-            var jSuites = window.jSuites;
-        }
-    }
-
-    return function() {
-        const self = this;
-
-        self.create = function(o) {
-            if (this.remotesearch === 'true') {
-                this.remoteSearch = true;
-            }
-            if (this.multiple === 'true') {
-                this.multiple = true;
-            }
-            if (this.autocomplete === 'true') {
-                this.autocomplete = true;
-            }
-            self.instance = jSuites.dropdown(o, this);
-        }
-
-        return `<div @ready="self.create(this)" name="{{self.name}}"></div>`;
-    }
-
+/**
+ * Implementar o page up and down
+ * botao reset e done
+ * traducoes
+ */
+if (!lemonade && typeof (require) === 'function') {
+    var lemonade = require('lemonadejs');
+}
+
+if (!Modal && typeof (require) === 'function') {
+    var Modal = require('@lemonadejs/modal');
+}
+
+if (!lazyloading && typeof (require) === 'function') {
+    var lazyloading = require('@lemonadejs/lazy-loading');
+}
+
+; (function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+    typeof define === 'function' && define.amd ? define(factory) :
+    global.Dropdown = factory();
+}(this, (function () {
+
+    const Dropdown = function () {
+        let self = this;
+
+        let group = null;
+        let value = [];
+        let cursor = null;
+
+        if (! self.width) {
+            self.width = 260;
+        }
+
+        const setCursor = function(index) {
+            let item = self.modal.lazyLoading.data[index];
+            if (typeof(item) !== 'undefined') {
+                item.cursor = true;
+                // Move to the item position: TODO!
+                if (! item.el || ! item.el.parentNode) {
+                    self.modal.lazyLoading.goto(item);
+                }
+            }
+        }
+
+        const removeCursor = function(reset) {
+            if (typeof(self.modal.lazyLoading.data[cursor]) !== 'undefined') {
+                self.modal.lazyLoading.data[cursor].cursor = false;
+            }
+            if (reset) {
+                // Cursor is null
+                cursor = null;
+            }
+        }
+
+        const moveCursor = function(direction, jump) {
+            // Remove cursor
+            removeCursor();
+            // Last item
+            let last = self.modal.lazyLoading.data.length - 1;
+            if (jump) {
+                if (direction < 0) {
+                    cursor = 0;
+                } else {
+                    cursor = last;
+                }
+            } else {
+                // Position
+                if (cursor === null) {
+                    cursor = 0;
+                } else {
+                    // Move previous
+                    cursor = cursor + direction;
+                }
+                // Reach the boundaries
+                if (direction < 0) {
+                    // Back to the last one
+                    if (cursor < 0) {
+                        cursor = last;
+                    }
+                } else {
+                    // Back to the first one
+                    if (cursor > last) {
+                        cursor = 0;
+                    }
+                }
+            }
+            // Add cursor
+            setCursor(cursor);
+        }
+
+        const updateLabel = function() {
+            if (value && value.length) {
+                self.input.textContent = value.filter(v => v.selected).map(i => i.text).join('; ');
+            }
+        }
+
+        self.onclose = function() {
+            // Identify the new state of the dropdown
+            self.state = false;
+            // Update label
+            updateLabel();
+            // Update value
+            self.value = getValue();
+            // Editable
+            self.el.children[0].removeAttribute('contenteditable');
+        }
+
+        self.onopen = function() {
+            // Value
+            let v = value[value.length-1];
+            // Move to the correct position
+            if (v) {
+                // Go to the last item in the array of values
+                self.modal.lazyLoading.goto(v);
+                // Mark the position of the cursor to the same element
+                cursor = self.modal.lazyLoading.data.indexOf(v);
+            } else {
+                // Loading the data inside the lazy loading
+                self.modal.lazyLoading.data = self.data;
+            }
+            // Reset search
+            if (self.autocomplete) {
+                // Clear input
+                self.input.textContent = '';
+                // Editable
+                self.el.children[0].setAttribute('contenteditable', true);
+                // Focus on the item
+                self.el.children[0].focus();
+            }
+
+            self.state = true;
+        }
+
+        const setValue = function(v) {
+            // Values
+            let newValue;
+            if (! v) {
+                newValue = [];
+            } else if (! Array.isArray(v)) {
+                if (typeof(v) === 'string') {
+                    newValue = v.split(';');
+                } else {
+                    newValue = [v];
+                }
+            } else {
+                newValue = v;
+            }
+
+            // Width && values
+            value = [];
+
+            self.data.map(function(s) {
+                // Select values
+                if (newValue.indexOf(s.value) !== -1) {
+                    s.selected = true;
+                    value.push(s);
+                } else {
+                    s.selected = false;
+                }
+            });
+
+            // Update label
+            updateLabel();
+        }
+
+        const getValue = function() {
+            if (value && value.length) {
+                return value.filter(v => v.selected).map(i => i.value);
+            }
+            return [];
+        }
+
+        self.onload = function () {
+            // Set the initial value
+            if (self.value) {
+                setValue(self.value);
+            }
+            // Re-order to make sure groups are in sequence
+            self.data = self.data.sort((a, b) => {
+                // Compare groups
+                if (a.group && b.group) {
+                    return a.group.localeCompare(b.group);
+                }
+                return 0;
+            });
+            // Update the data of the lazy loading component
+            self.modal.lazyLoading.data = self.data;
+            // Estimate width
+            let width = self.width;
+            // Width && values
+            self.data.map(function (s) {
+                // Estimated width of the element
+                width = Math.max(width, s.text.length * 8);
+            });
+            // Adjust the width
+            let w = self.el.children[0].offsetWidth;
+            if (width < w) {
+                width = w;
+            }
+            // Estimated with based on the text
+            if (self.width < width) {
+                self.width = width;
+            }
+            self.el.style.width = self.width + 'px';
+
+            // Focus out of the component
+            self.el.addEventListener('focusout', function(e) {
+                if (! (e.relatedTarget && self.el.contains(e.relatedTarget)) && ! self.el.contains(e.relatedTarget)) {
+                    if (! self.modal.closed) {
+                        self.close();
+                    }
+                }
+            })
+
+            self.el.addEventListener('keydown', function(e) {
+                if (e.key === 'ArrowUp') {
+                    moveCursor(-1);
+                } else if (e.key === 'ArrowDown') {
+                    moveCursor(1);
+                } else if (e.key === 'Home') {
+                    moveCursor(-1, true);
+                } else if (e.key === 'End') {
+                    moveCursor(1, true);
+                } else if (e.key === 'Enter') {
+                    // Select
+                    if (typeof(self.modal.lazyLoading.data[cursor]) !== 'undefined') {
+                        self.select(e, self.modal.lazyLoading.data[cursor]);
+                        e.preventDefault();
+                        e.stopImmediatePropagation();
+                    }
+                } else {
+                    if (self.state && self.autocomplete) {
+                        // Filter options
+                        let data;
+                        if (! self.input.textContent) {
+                            data = self.data;
+                        } else {
+                            data = self.data.filter(item => {
+                                return item.text.toLowerCase().includes(self.input.textContent.toLowerCase()) ||
+                                    (item.group && item.group.toLowerCase().includes(self.input.textContent.toLowerCase()));
+                            });
+                        }
+                        // Cursor
+                        removeCursor(true);
+                        // Update the data from the dropdown
+                        self.modal.lazyLoading.data = data;
+                    }
+                }
+            })
+
+            if (document.documentElement.clientWidth < 800) {
+                self.animation = true;
+            }
+        }
+
+        self.onchange = function (prop) {
+            if (prop === 'value') {
+                setValue(self.value);
+            }
+        }
+
+        self.open = function () {
+            if (self.modal.closed) {
+                self.modal.closed = false;
+            }
+        }
+
+        self.close = function () {
+            // Close the modal
+            self.modal.closed = true;
+            // Remove cursor
+            removeCursor(true);
+        }
+
+        self.toggle = function() {
+            if (self.modal.closed) {
+                self.open();
+            } else {
+                self.close();
+            }
+        }
+
+        self.select = function(e, s) {
+            if (self.multiple === true) {
+                let position = value.indexOf(s);
+                if (position === -1) {
+                    value.push(s);
+                    s.selected = true;
+                } else {
+                    value.splice(position, 1);
+                    s.selected = false;
+                }
+            } else {
+                if (value[0]) {
+                    value[0].selected = false;
+                }
+                s.selected = true;
+                value = [s];
+                // Close the modal
+                self.close();
+            }
+        }
+
+        self.getGroup = function(g) {
+            let groupName = g && g === group ? '' : g;
+            group = g;
+            return groupName;
+        }
+
+        return `<div class="lm-dropdown" data-type="{{self.type}}" data-state="{{self.state}}">
+            <div class="lm-dropdown-input" onmousedown="self.toggle" onfocus="self.open" placeholder="{{self.placeholder}}" :ref="self.input" tabindex="0"></div>
+            <Modal :ref="self.modal" :closed="true" :onclose="self.onclose" :onopen="self.onopen" :width="self.width" :animation="self.animation">
+                <Lazyloading :data="self.data" :ref="self.lazyLoading" :height="330">
+                    <div class="lm-dropdown-item" onclick="self.parent.parent.parent.select" data-cursor="{{self.cursor}}" data-selected="{{self.selected}}" data-group="{{self.parent.parent.parent.getGroup(self.group)}}">
+                        <div><img :src="self.image" /><span>{{self.text}}</span></div>
+                    </div>
+                </Lazyloading>    
+            </Modal>
+        </div>`;
+    }
+
+    lemonade.setComponents({ Dropdown: Dropdown });
+
+    return function (root, options) {
+        if (typeof (root) === 'object') {
+            lemonade.render(Dropdown, root, options)
+            return options;
+        } else {
+            return Dropdown.call(this, root)
+        }
+    }
 })));

package/dist/react.js

@@ -0,0 +1,37 @@
+// @ts-nocheck
+import React, { useRef, useEffect } from "react";
+import Component from './index';
+
+
+// @ts-ignore
+export default React.forwardRef((props, mainReference) => {
+    // Dom element
+    const Ref = useRef(null);
+
+    // Get the properties for the spreadsheet
+    let options = { ...props };
+
+    useEffect(() => {
+        // @ts-ignore
+        if (!Ref.current.innerHTML) {
+            mainReference.current = Component(Ref.current, options);
+        }
+    }, []);
+
+    useEffect(() => {
+        for (let key in props) {
+            if (props.hasOwnProperty(key) && mainReference.current.hasOwnProperty(key)) {
+                if (props[key] !== mainReference.current[key]) {
+                    mainReference.current[key] = props[key];
+                }
+            }
+        }
+    }, [props])
+
+    let prop = {
+        ref: Ref,
+        style: { height: '100%', width: '100%' }
+    };
+
+    return React.createElement("div", prop);
+})

package/dist/style.css

@@ -0,0 +1,178 @@
+.lm-dropdown {
+    display: inline-block;
+    user-select: none;
+    cursor: pointer;
+    box-sizing: border-box;
+}
+
+.lm-dropdown .lm-modal {
+    padding: 0;
+    min-width: initial;
+    min-height: 30px;
+    border: 1px solid #ccc;
+    border-radius: 0;
+}
+
+.lm-dropdown .lm-lazy {
+    max-height: 300px;
+}
+
+.lm-dropdown-input {
+    display: inline-flex;
+    padding: 5px 30px 5px 10px;
+    align-items: center;
+    position: relative;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    appearance: none;
+    cursor: pointer;
+    box-sizing: border-box;
+    width: 100%;
+    background-repeat: no-repeat;
+    background-position: top 50% right 0;
+    background-image: url("data:image/svg+xml,%0A%3Csvg xmlns='http://www.w3.org/2000/svg' width='24' height='24' viewBox='0 0 24 24'%3E%3Cpath fill='none' d='M0 0h24v24H0V0z'/%3E%3Cpath d='M7 10l5 5 5-5H7z' fill='gray'/%3E%3C/svg%3E");
+    border: 1px solid #ccc;
+}
+
+.lm-dropdown-input:empty::before {
+    content: "\00a0";
+}
+
+.lm-dropdown[data-state="true"] .lm-dropdown-input[placeholder]:empty::before {
+    content: "\00a0" attr(placeholder);
+    color: #aaa;
+}
+
+.lm-dropdown-options {
+    width: 100%;
+}
+
+.lm-dropdown-item {
+    box-sizing: border-box;
+}
+
+.lm-dropdown-item[data-group]::before {
+    content: attr(data-group);
+    display: block;
+    padding: 8px;
+    font-weight: bold;
+    width: 100%;
+    background-color: #FFF;
+    color: #000;
+}
+
+.lm-dropdown-item > div {
+    white-space: nowrap;
+    text-align: left;
+    text-overflow: ellipsis;
+    overflow: hidden;
+    color: #000;
+    display: flex;
+    align-items: center;
+    padding: 4px 40px 4px 16px;
+    position: relative;
+    box-sizing: border-box;
+}
+
+.lm-dropdown-item > div > img {
+    width: 24px;
+    height: 24px;
+    margin-left: -6px;
+    margin-right: 6px;
+}
+
+.lm-dropdown-item > div > img[src=''] {
+    display: none;
+}
+
+.lm-dropdown-item > div:hover {
+    background-color: dodgerblue;
+    color: white;
+}
+
+.lm-dropdown-item[data-cursor="true"] > div {
+    background-color: #eee;
+}
+
+.lm-dropdown-item[data-selected="true"] > div {
+    background-color: dodgerblue;
+    color: white;
+}
+
+.lm-dropdown-item[data-selected="true"] > div::after {
+    content: '✓';
+    position: absolute;
+    right: 10px;
+    line-height: 24px;
+}
+
+/** Picker */
+
+.lm-dropdown[data-type="picker"] .lm-modal {
+    position: absolute;
+    bottom: 0;
+    left: 0;
+    width: 100% !important;
+    height: 300px !important;
+}
+
+.lm-dropdown[data-type="picker"] .lm-dropdown-item > div {
+    border-bottom: solid 1px rgba(0, 0, 0, 0.2);
+    text-transform: uppercase;
+    font-size: 1.1em;
+    padding: 16px;
+}
+
+.lm-dropdown[data-type="picker"] .lm-dropdown-item[data-group]::before {
+    text-align: center;
+    border-bottom: solid 1px rgba(0, 0, 0, 0.2);
+    padding: 16px;
+}
+
+/** Searchbar */
+
+.lm-dropdown[data-type="searchbar"][data-state="true"] {
+    position: absolute;
+    top: 0;
+    left: 0;
+    width: 100% !important;
+    height: 100% !important;
+    display: flex;
+    flex-direction: column;
+    background-color: #fff;
+}
+
+.lm-dropdown[data-type="searchbar"][data-state="true"] .lm-dropdown-input {
+    font-size: 1.5em;
+    border-radius: 0;
+    border: 0;
+    border-bottom: 1px solid #ccc;
+    outline: none;
+    background-color: #fff;
+    padding-top: 0;
+    padding-bottom: 0;
+    line-height: 60px;
+    height: 60px;
+}
+
+.lm-dropdown[data-type="searchbar"] .lm-modal {
+    max-height: initial;
+    bottom: 0;
+    width: 100% !important;
+    height: calc(100% - 60px) !important;
+    border: 0;
+}
+
+.lm-dropdown[data-type="searchbar"] .lm-dropdown-item > div {
+    border-bottom: solid 1px rgba(0, 0, 0, 0.2);
+    text-transform: uppercase;
+    font-size: 1.1em;
+    padding: 16px;
+}
+
+.lm-dropdown[data-type="searchbar"] .lm-dropdown-item[data-group]::before {
+    text-align: center;
+    border-bottom: solid 1px rgba(0, 0, 0, 0.2);
+    padding: 16px;
+}

package/dist/vue.js

@@ -0,0 +1,45 @@
+import { h } from 'vue';
+import component from "./index";
+
+
+export default {
+    inheritAttrs: false,
+    mounted() {
+        let options = {
+            ...this.$attrs
+        };
+
+        this.el = this.$refs.container;
+
+        this.current = component(this.$refs.container, options);
+    },
+    setup() {
+        let containerProps = {
+            ref: 'container',
+            style: {
+                width: '100%',
+                height: '100%',
+            }
+        };
+        return () => h('div', containerProps);
+    },
+    watch: {
+        $attrs: {
+            deep: true,
+            handler() {
+                this.updateState();
+            }
+        }
+    },
+    methods: {
+        updateState() {
+            for (let key in this.$attrs) {
+                if (this.$attrs.hasOwnProperty(key) && this.current.hasOwnProperty(key)) {
+                    if (this.$attrs[key] !== this.current[key]) {
+                        this.current[key] = this.$attrs[key];
+                    }
+                }
+            }
+        }
+    }
+}

package/package.json

@@ -1,22 +1,23 @@
-{
-    "name": "@lemonadejs/dropdown",
-    "title": "LemonadeJS dropdown",
-    "description": "LemonadeJS dropdown integration.",
-    "author": {
-        "name": "Contact <contact@lemonadejs.net>",
-        "url": "https://lemonadejs.net"
-    },
-    "keywords": [
-        "javascript dropdown",
-        "lemonadejs plugins",
-        "js",
-        "library",
-        "javascript plugins"
-    ],
-    "dependencies": {
-        "lemonadejs": "^3.0.6",
-        "jsuites": "^4.17.7"
-    },
-    "main": "dist/index.js",
-    "version": "2.0.0"
-}
+{
+    "name": "@lemonadejs/dropdown",
+    "title": "LemonadeJS dropdown",
+    "description": "LemonadeJS dropdown integration.",
+    "author": {
+        "name": "Contact <contact@lemonadejs.net>",
+        "url": "https://lemonadejs.net"
+    },
+    "keywords": [
+        "javascript dropdown",
+        "lemonadejs plugins",
+        "js",
+        "library",
+        "javascript plugins"
+    ],
+    "dependencies": {
+        "lemonadejs": "^4.0.6",
+        "@lemonadejs/modal": "2.3.3",
+        "@lemonadejs/lazy-loading": "1.0.0"
+    },
+    "main": "dist/index.js",
+    "version": "3.0.4"
+}