@zeedhi/vuetify 3.0.6 → 3.0.8

package/dist/composables/gridSorting.js

@@ -0,0 +1,19 @@
+import { computed } from 'vue';
+/**
+ * Composable for components that use grid color vars
+ */
+export function useGridSorting({ instance, }) {
+    const updateSortBy = (sortBy) => {
+        instance.changeOrder(sortBy);
+    };
+    const sortBy = computed(() => {
+        return instance.datasource.order.map((orderString) => {
+            const [key, order] = orderString.split('.');
+            return { key, order };
+        });
+    });
+    return {
+        updateSortBy,
+        sortBy,
+    };
+}

package/dist/composables/hasSlot.js

@@ -0,0 +1,25 @@
+import { useSlots } from 'vue';
+/**
+ * Composable for components that need to check if a slot is defined
+ */
+export function useHasSlot() {
+    const slots = useSlots();
+    const result = {};
+    const checkHasContent = (vnode) => {
+        // Ignore fragment nodes (Symbol(v-fgt))
+        if (vnode.type === Symbol.for('v-fgt')) {
+            return false;
+        }
+        // Check for non-empty text content or elements
+        return vnode.type || (typeof vnode.children === 'string' && vnode.children.trim() !== '');
+    };
+    for (const slotName in slots) {
+        const slot = slots[slotName];
+        const hasContent = slot?.().some((vnode) => checkHasContent(vnode));
+        result[slotName] = {
+            slot,
+            hasContent: !!hasContent,
+        };
+    }
+    return result;
+}

package/dist/composables/index.js

@@ -0,0 +1,16 @@
+export * from './cellSelection';
+export * from './columnDrag';
+export * from './columnResize';
+export * from './density';
+export * from './doubleClick';
+export * from './fixedColumns';
+export * from './gridColorVars';
+export * from './gridColumns';
+export * from './gridSelection';
+export * from './gridSorting';
+export * from './hasSlot';
+export * from './maska';
+export * from './tableNavigation';
+export * from './virtualScroll';
+export * from './watchUrl';
+export * from './useIsMobile';

package/dist/composables/maska.js

@@ -0,0 +1,36 @@
+import { Mask } from '@zeedhi/core';
+import { reactive, ref } from 'vue';
+/**
+ * Composable for text inputs that need basic Mask formatting
+ * @returns options to be passed to a v-maska directive
+ */
+export function useMaska(instance, options) {
+    const currentMask = ref('');
+    /**
+     * Get the current mask. If using dynamic mask, this will call the mask as a function
+     */
+    const getCurrentMask = (value) => {
+        const mask = instance.getMask();
+        if (typeof mask === 'function') {
+            const parsedValue = Mask.getValueWithoutMask(value);
+            return mask(parsedValue);
+        }
+        return mask;
+    };
+    const getMaskOptions = () => {
+        if (options.disable)
+            return {};
+        return {
+            mask: () => {
+                return currentMask.value || undefined;
+            },
+            preProcess: (value) => {
+                currentMask.value = getCurrentMask(value);
+                return value;
+            },
+            eager: false,
+        };
+    };
+    const maskOptions = reactive(getMaskOptions());
+    return { maskOptions };
+}

package/dist/composables/tableNavigation.js

@@ -0,0 +1,126 @@
+/**
+ * Composable for components that can use table navigation
+ */
+export function useTableNavigation({ instance, rootEl, }) {
+    const navigate = (direction, event) => {
+        if (direction === 'up' || direction === 'down') {
+            navigateVertical(direction);
+            return;
+        }
+        if (direction === 'right') {
+            navigateRight(event);
+            return;
+        }
+        navigateLeft(event);
+    };
+    instance.setViewNavigate(navigate);
+    const navigateRight = (event) => {
+        event?.preventDefault();
+        const tdNode = getTdNode(document.activeElement);
+        if (!tdNode)
+            return;
+        let { nextElementSibling } = tdNode;
+        if (!nextElementSibling) {
+            const trNode = tdNode.parentElement;
+            if (!trNode)
+                return;
+            let nextTr;
+            do {
+                nextTr = trNode.nextElementSibling;
+                if (!nextTr)
+                    return;
+            } while (!isElementVisible(nextTr));
+            [nextElementSibling] = nextTr.children;
+        }
+        focusElement(nextElementSibling);
+    };
+    const navigateLeft = (event) => {
+        event?.preventDefault();
+        const tdNode = getTdNode(document.activeElement);
+        if (!tdNode)
+            return;
+        let { previousElementSibling } = tdNode;
+        if (!previousElementSibling) {
+            const trNode = tdNode.parentElement;
+            if (!trNode)
+                return;
+            let previousTr;
+            do {
+                previousTr = trNode.previousElementSibling;
+                if (!previousTr)
+                    return;
+            } while (!isElementVisible(previousTr));
+            previousElementSibling = previousTr.children[previousTr.children.length - 1];
+        }
+        focusElement(previousElementSibling);
+    };
+    const isElementVisible = (element) => {
+        const style = window.getComputedStyle(element);
+        const isVisible = style.display !== 'none';
+        return isVisible;
+    };
+    // selector for input-type elements that are not disabled, or elements with tabindex
+    const focusableSelector = 'button:not([disabled]), a:not([disabled]), input:not([disabled]), select:not([disabled])' +
+        ', textarea:not([disabled]), [tabindex]:not([tabindex="-1"])';
+    /**
+     * Focus an element or its first focusable children
+     * @param element element to be focused
+     */
+    const focusElement = (element) => {
+        if (!element)
+            return;
+        const focusableChild = element.querySelector(focusableSelector);
+        const nextFocusableElement = focusableChild && isElementVisible(focusableChild) ? focusableChild : element;
+        nextFocusableElement.focus({ preventScroll: true });
+        if (nextFocusableElement instanceof HTMLInputElement)
+            nextFocusableElement.select();
+    };
+    const getTdNode = (element) => {
+        if (!element)
+            return null;
+        if (element.nodeName === 'TD')
+            return element;
+        return getTdNode(element.parentElement);
+    };
+    const getArrayFromElementTag = (tagName, node) => {
+        if (node)
+            return Array.from(node.getElementsByTagName(tagName));
+        return [];
+    };
+    const getArrayFromTdElement = (node) => {
+        return getArrayFromElementTag('TD', node);
+    };
+    const getArrayFromTrElement = (node) => {
+        return getArrayFromElementTag('TR', node).filter(isElementVisible);
+    };
+    const findNextTd = (direction, trIndex, tdIndex, trCollection) => {
+        const up = direction === 'up';
+        if ((up && trIndex <= 0) || (!up && trIndex >= trCollection.length - 1)) {
+            return undefined;
+        }
+        const nextTr = trCollection[up ? trIndex - 1 : trIndex + 1];
+        const index = Math.min(tdIndex, nextTr.childElementCount - 1);
+        const nextTd = getArrayFromTdElement(nextTr)[index];
+        return nextTd;
+    };
+    const navigateVertical = (direction) => {
+        const hasActive = rootEl.value?.querySelector('tbody')?.contains(document.activeElement);
+        // if not cellSelection and activeElement is not inside tbody, should navigate from datasource
+        if (!hasActive) {
+            instance.navigateDatasource(direction);
+            return;
+        }
+        const tdNode = getTdNode(document.activeElement);
+        const trNode = tdNode?.parentElement;
+        if (!tdNode || !trNode)
+            return;
+        const tdIndex = getArrayFromTdElement(trNode).indexOf(tdNode);
+        const trCollection = getArrayFromTrElement(trNode.parentElement);
+        const trIndex = trCollection.indexOf(trNode);
+        const nextElement = findNextTd(direction, trIndex, tdIndex, trCollection);
+        if (!nextElement)
+            return;
+        focusElement(nextElement);
+    };
+    return { navigate };
+}

package/dist/composables/useIsMobile.js

@@ -0,0 +1,8 @@
+import { Utils } from '@zeedhi/core';
+import { computed } from 'vue';
+export function useIsMobile() {
+    const isMobile = computed(() => {
+        return Utils.isMobile();
+    });
+    return { isMobile };
+}

package/dist/composables/useTableLayout.js

@@ -0,0 +1,212 @@
+import { TekFilterHelper, TekGridColumn, TekRestDatasource, } from '@zeedhi/common';
+import { Utils } from '@zeedhi/core';
+import cloneDeep from 'lodash.clonedeep';
+import { NotProvidedError } from '../errors/not-provided';
+import { computed, inject, nextTick, provide } from 'vue';
+export function useTableLayout() {
+    const applyLayout = inject('applyLayout');
+    const getColumnElements = inject('getColumnElements');
+    const getTableWidth = inject('getTableWidth');
+    if (!applyLayout) {
+        throw new NotProvidedError('applyLayout');
+    }
+    if (!getColumnElements) {
+        throw new NotProvidedError('getColumnElements');
+    }
+    if (!getTableWidth) {
+        throw new NotProvidedError('getTableWidth');
+    }
+    return { applyLayout, getColumnElements, getTableWidth };
+}
+export function provideTableLayout({ instance, rootEl, }) {
+    const tableElement = rootEl.value?.querySelector('table');
+    const columnDictionary = computed(() => getColumnDictionary(instance.columns));
+    const datasourceDynamicFilter = () => {
+        const datasource = instance.datasource;
+        if (datasource instanceof TekRestDatasource)
+            return datasource.dynamicFilter;
+        return {};
+    };
+    const getColumnDictionary = (columns) => {
+        const columnDictionary = {};
+        columns.forEach((column) => {
+            columnDictionary[column.name] = column;
+        });
+        return columnDictionary;
+    };
+    const addMissingColumns = (layout) => {
+        const layoutColumnNames = layout.columns?.map((column) => column.name) || [];
+        const columnNames = Object.keys(columnDictionary.value);
+        columnNames.forEach((columnName) => {
+            if (!layoutColumnNames.includes(columnName)) {
+                layout.columns?.push(columnDictionary.value[columnName]);
+            }
+        });
+    };
+    const setHelperValue = (column, value) => {
+        if (column instanceof TekGridColumn) {
+            if (!Array.isArray(column.filterProps) && typeof value === 'string') {
+                column.filterProps.helperValue = value;
+            }
+            else if (Array.isArray(column.filterProps) && Array.isArray(value)) {
+                column.filterProps.forEach((prop, index) => {
+                    prop.value = value[index];
+                });
+            }
+        }
+    };
+    const getHelperValues = (dynamicFilter, columns) => {
+        const filter = cloneDeep(dynamicFilter);
+        Object.keys(filter).forEach((columnName) => {
+            const filterOptions = filter[columnName];
+            const column = columns[columns.findIndex((col) => col.name === columnName)];
+            const { filterHelperValue } = column;
+            filterOptions.forEach((item) => {
+                if (['IN', 'NOT_IN', 'BETWEEN'].includes(item.operation) && !Array.isArray(item.value)) {
+                    item.value = item.value.split(';');
+                }
+                let helperValue = '';
+                if (!Array.isArray(filterHelperValue)) {
+                    helperValue = filterHelperValue;
+                }
+                else {
+                    Object.keys(filterHelperValue).forEach((key) => {
+                        const value = filterHelperValue[key] || '';
+                        if (`${item.relation || 'AND'}-${item.operation || 'CONTAINS'}` === key) {
+                            helperValue = value;
+                        }
+                    });
+                }
+                if (helperValue) {
+                    const columnObj = instance.getColumn(column.name);
+                    item.value = TekFilterHelper.getValue(helperValue, columnObj);
+                }
+            });
+        });
+        return filter;
+    };
+    /**
+     * Applies the default grid layout
+     * @returns a boolean to indicate whether the group parameters changed
+     */
+    const applyDefaultLayout = (defaultLayout) => {
+        let groupParamsChanged = false;
+        instance.datasource.order = [...defaultLayout.originalDatasourceOrder];
+        instance.datasource.filter = { ...defaultLayout.originalDatasourceFilter };
+        if (instance.datasource instanceof TekRestDatasource) {
+            instance.datasource.dynamicFilter = getHelperValues(defaultLayout.originalDatasourceDynamicFilter, defaultLayout.originalColumnProps);
+        }
+        instance.columns = defaultLayout.originalColumnProps.map((defaultColumn) => {
+            const col = columnDictionary.value[defaultColumn.name];
+            groupParamsChanged =
+                groupParamsChanged ||
+                    col.grouped !== defaultColumn.grouped ||
+                    col.groupOpened !== defaultColumn.groupOpened ||
+                    col.aggregation !== defaultColumn.aggregation;
+            col.isVisible = defaultColumn.isVisible ?? col.isVisible;
+            col.label = defaultColumn.label ?? col.label;
+            col.align = defaultColumn.align ?? col.align;
+            col.fixed = defaultColumn.fixed ?? col.fixed;
+            col.grouped = defaultColumn.grouped ?? col.grouped;
+            col.groupOpened = defaultColumn.groupOpened ?? col.groupOpened;
+            col.aggregation = defaultColumn.aggregation ?? col.aggregation;
+            col.minWidth = defaultColumn.minWidth ?? col.minWidth;
+            col.maxWidth = defaultColumn.maxWidth ?? col.maxWidth;
+            col.width = defaultColumn.width ?? col.width;
+            setHelperValue(col, defaultColumn.filterHelperValue || '');
+            return col;
+        });
+        if (tableElement) {
+            tableElement.style.width = '100%';
+            const columnElements = Array.from(tableElement.querySelectorAll('tr th:not(.selectable)'));
+            columnElements.forEach((item) => {
+                item.style.width = 'unset';
+            });
+        }
+        return groupParamsChanged;
+    };
+    const applyNewLayout = (layout, changeLayoutCallback) => {
+        const gridColumnNames = Object.keys(columnDictionary.value);
+        let layoutChanged = false;
+        // removes columns that are in the layout but not in grid
+        layout.columns = layout.columns?.filter((column) => {
+            const isInGrid = gridColumnNames.includes(column.name);
+            if (!isInGrid)
+                layoutChanged = true;
+            return isInGrid;
+        });
+        if (layoutChanged) {
+            changeLayoutCallback(layout);
+        }
+        if (tableElement)
+            tableElement.style.width = layout.gridWidth || 'auto';
+        instance.datasource.order = layout.order !== undefined ? layout.order : instance.datasource.order;
+        instance.datasource.filter = layout.filter !== undefined ? layout.filter : instance.datasource.filter;
+        if (instance.datasource instanceof TekRestDatasource && layout.dynamicFilter !== undefined) {
+            instance.datasource.dynamicFilter = getHelperValues(layout.dynamicFilter, layout.columns || instance.columns);
+        }
+        if (layout.columns) {
+            instance.columns = layout.columns.map((column) => {
+                const col = columnDictionary.value[column.name];
+                col.label = column.label !== undefined ? column.label : col.label;
+                col.align = column.align !== undefined ? column.align : col.align;
+                col.isVisible = column.isVisible !== undefined ? column.isVisible : col.isVisible;
+                col.fixed = !!column.fixed;
+                col.grouped = !!column.grouped;
+                col.groupOpened = !!column.groupOpened;
+                col.aggregation = column.aggregation;
+                col.minWidth = column.minWidth || '';
+                col.maxWidth = column.maxWidth || '';
+                col.width = column.width;
+                setHelperValue(col, column.filterHelperValue || '');
+                return col;
+            });
+            // wait to change column orders
+            nextTick(() => {
+                gridColumnNames.forEach((_key, index) => {
+                    const columnElement = tableElement?.querySelector(`tr th:not(.selectable)[index="${index}"]`);
+                    if (columnElement) {
+                        columnElement.style.width = layout.columns[index].width || 'unset';
+                    }
+                });
+            });
+        }
+    };
+    const applyLayout = ({ layout, defaultLayout, changeLayoutCallback, }) => {
+        const oldOrder = instance.datasource.order;
+        const oldFilter = instance.datasource.filter;
+        const oldDynamicFilter = datasourceDynamicFilter();
+        let groupParamsChanged = false;
+        if (layout) {
+            addMissingColumns(layout);
+            applyNewLayout(layout, changeLayoutCallback);
+        }
+        else {
+            groupParamsChanged = applyDefaultLayout(defaultLayout);
+        }
+        if ((!Utils.isEqual(instance.datasource.order, oldOrder) ||
+            !Utils.isEqual(instance.datasource.filter, oldFilter) ||
+            !Utils.isEqual(datasourceDynamicFilter(), oldDynamicFilter)) &&
+            !groupParamsChanged) {
+            // Se os parametros de agrupamento tiverem sido alterados um get é feito automaticamente
+            instance.loadAfterTasks();
+        }
+    };
+    const getColumnElements = () => {
+        const elementDict = {};
+        const columnElements = tableElement?.querySelectorAll('tr th:not(.selectable)[index]') || [];
+        columnElements.forEach((el) => {
+            const index = el.getAttribute('index');
+            if (index === null)
+                return;
+            elementDict[index] = el;
+        });
+        return elementDict;
+    };
+    const getTableWidth = () => {
+        return tableElement ? window.getComputedStyle(tableElement).width : 'auto';
+    };
+    provide('applyLayout', applyLayout);
+    provide('getColumnElements', getColumnElements);
+    provide('getTableWidth', getTableWidth);
+}

package/dist/composables/virtualScroll.js

@@ -0,0 +1,92 @@
+import { reactive, ref } from 'vue';
+/**
+ * Composable for components that use grid color vars
+ */
+export function useVirtualScroll({ instance, rootEl, renderedData, }) {
+    const scrollData = reactive({
+        start: 0,
+        startHeight: 0,
+        perPage: 0,
+        endHeight: 0,
+        rowHeight: 0,
+        initialized: false,
+    });
+    const lastStart = ref(0);
+    const onScroll = (event) => {
+        const { scrollTop } = event.target;
+        const rows = Math.floor(scrollTop / scrollData.rowHeight);
+        const start = rows + scrollData.perPage > renderedData.value.length
+            ? Math.max(0, renderedData.value.length - scrollData.perPage)
+            : rows;
+        if (lastStart.value !== start) {
+            lastStart.value = start;
+            scrollData.start = start;
+            updateScrollData(renderedData.value);
+        }
+    };
+    const updateScrollData = (data) => {
+        const { start, rowHeight, perPage } = scrollData;
+        const cache = instance.virtualScrollCache;
+        scrollData.startHeight = Math.max(start - cache, 0) * rowHeight;
+        scrollData.endHeight = Math.max(data.length - start - perPage - cache, 0) * rowHeight;
+    };
+    const updateScrollPerPage = () => {
+        const tableWrapperHeight = scrollData.tableWrapper.clientHeight;
+        const tableHeader = rootEl.value?.querySelector('thead');
+        const tableHeaderHeight = tableHeader.clientHeight;
+        scrollData.perPage = Math.ceil((tableWrapperHeight - tableHeaderHeight) / scrollData.rowHeight);
+        updateScrollData(renderedData.value);
+    };
+    const initializeScrollData = (el) => {
+        const tbodyEl = el.querySelector('tbody');
+        const tableWrapperEl = el.querySelector('.v-table__wrapper');
+        if (!tbodyEl || !tableWrapperEl) {
+            return;
+        }
+        scrollData.tbody = tbodyEl;
+        const tr = document.createElement('tr');
+        scrollData.tbody.append(tr);
+        const td = document.createElement('td');
+        td.className = 'zd-grid__cell';
+        tr.append(td);
+        scrollData.rowHeight = td.clientHeight;
+        tr.remove();
+        scrollData.tableWrapper = tableWrapperEl;
+        scrollData.tableWrapper.addEventListener('scroll', onScroll);
+        const observer = new ResizeObserver(updateScrollPerPage);
+        observer.observe(tableWrapperEl);
+        scrollData.start = 0;
+        scrollData.initialized = true;
+    };
+    const calcScrollData = () => {
+        if (!instance.virtualScroll || scrollData.initialized || !rootEl.value)
+            return;
+        if (!scrollData.tbody) {
+            initializeScrollData(rootEl.value);
+        }
+        updateScrollPerPage();
+    };
+    const addTopPadding = () => {
+        return instance.virtualScroll && scrollData.start > instance.virtualScrollCache;
+    };
+    const addBottomPadding = () => {
+        return (instance.virtualScroll &&
+            scrollData.start + scrollData.perPage + instance.virtualScrollCache < renderedData.value.length);
+    };
+    /**
+     * Checks if a row should be rendered based on it's index
+     */
+    const shouldRender = (index) => {
+        // checks if index position is inside the cached range
+        const isAfterTopCache = index >= scrollData.start - instance.virtualScrollCache;
+        const isBeforeBottomCache = index <= scrollData.start + scrollData.perPage + instance.virtualScrollCache;
+        return !instance.virtualScroll || (isAfterTopCache && isBeforeBottomCache);
+    };
+    return {
+        calcScrollData,
+        scrollData,
+        addTopPadding,
+        addBottomPadding,
+        shouldRender,
+    };
+}

package/dist/composables/watchUrl.js

@@ -0,0 +1,14 @@
+import { watch } from 'vue';
+import { useRoute } from 'vue-router';
+/**
+ * Composable for components that can use datasource watchUrl feature
+ */
+export function useWatchUrl(instance) {
+    const route = useRoute();
+    watch(() => route.fullPath, () => {
+        if (instance.datasource.urlHasChanged()) {
+            instance.datasource.get();
+        }
+    });
+    return {};
+}

package/dist/errors/index.js

@@ -0,0 +1,3 @@
+export * from './row-not-found';
+export * from './zeedhi-error';
+export * from './not-provided';

package/dist/errors/not-provided.js

@@ -0,0 +1,11 @@
+import { ZeedhiError } from './zeedhi-error';
+/**
+ * RowNotFound error
+ */
+export class NotProvidedError extends ZeedhiError {
+    constructor(provides) {
+        const text = Array.isArray(provides) ? provides.join(', ') : provides;
+        super(`component requires ${text} to be provided`);
+        this.name = 'NotProvidedError';
+    }
+}

package/dist/errors/row-not-found.js

@@ -0,0 +1,9 @@
+import { ZeedhiError } from './zeedhi-error';
+/**
+ * RowNotFound error
+ */
+export class RowNotFoundError extends ZeedhiError {
+    constructor(id) {
+        super(`Row with id ${id} not found`);
+    }
+}

package/dist/errors/zeedhi-error.js

@@ -0,0 +1,8 @@
+/**
+ * Base Zeedhi error
+ */
+export class ZeedhiError extends Error {
+    constructor(message) {
+        super(`[Zeedhi Vue err]: ${message}`);
+    }
+}

package/dist/index.js

@@ -0,0 +1,49 @@
+import { initTheme } from '@zeedhi/common';
+import { ViewService } from '@zeedhi/core';
+import { nextTick } from 'vue';
+import { PrismEditor } from 'vue-prism-editor';
+// Vuetify
+import { createVuetify } from 'vuetify';
+import * as components from 'vuetify/components';
+import * as directives from 'vuetify/directives';
+import * as labs from 'vuetify/labs/components';
+import 'vuetify/styles';
+import { SlVueTreeNext } from 'sl-vue-tree-next';
+import { RegisterComponents } from './components';
+import './styles/index.scss';
+import { formatSizePlugin, getIconPlugin, styleObjectPlugin } from './utils/plugins';
+const ZeedhiVuetify = {
+    install(app, { theme, icons, display } = {}) {
+        const vuetify = createVuetify({
+            components: {
+                ...components,
+                ...labs,
+            },
+            directives,
+            theme: initTheme(theme),
+            icons,
+            display,
+        });
+        app.use(vuetify);
+        ViewService.setViewNextTick(nextTick);
+        // Prism Code Editor
+        app.component('PrismEditor', PrismEditor);
+        // Tree component
+        app.component('SlVueTree', SlVueTreeNext);
+        RegisterComponents(app);
+        // getIcon
+        // eslint-disable-next-line no-param-reassign
+        app.config.globalProperties.$getIcon = getIconPlugin;
+        // formatSize
+        // eslint-disable-next-line no-param-reassign
+        app.config.globalProperties.$formatSize = formatSizePlugin;
+        // styleObject
+        // eslint-disable-next-line no-param-reassign
+        app.config.globalProperties.$styleObject = styleObjectPlugin;
+    },
+};
+export * from './errors';
+export * from './utils';
+export * from './components';
+export * from './composables';
+export default ZeedhiVuetify;

package/dist/propsMixins/heightProps.js

@@ -0,0 +1,17 @@
+export const HeightProps = {
+    fillHeight: {
+        type: [Boolean, String],
+        default: false,
+    },
+    height: {
+        type: [Number, String],
+    },
+    minHeight: {
+        type: [Number, String],
+        default: 'auto',
+    },
+    maxHeight: {
+        type: [Number, String],
+        default: 'none',
+    },
+};

package/dist/propsMixins/index.js

@@ -0,0 +1,3 @@
+import { HeightProps } from './heightProps';
+import { WidthProps } from './widthProps';
+export { HeightProps, WidthProps };

package/dist/propsMixins/interfaces.js

@@ -0,0 +1 @@
+export {};