@nu-art/thunderstorm-frontend 0.400.5

package/components/TS_MemoryMonitor/TS_MemoryMonitor.scss

@@ -0,0 +1,31 @@
+/*!
+ * Thunderstorm is a full web app framework!
+ *
+ * Typescript & Express backend infrastructure that natively runs on firebase function
+ * Typescript & React frontend infrastructure
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+.ts-memory-monitor {
+  background: #ffffffaa;
+  padding: 8px;
+  border-radius: 8px;
+  position: fixed;
+  top: calc(100% - 80px);
+  left: calc(100% - 160px);
+  pointer-events: none;
+  z-index: 500;
+}

package/components/TS_MemoryMonitor/index.d.ts

@@ -0,0 +1 @@
+export * from './TS_MemoryMonitor.js';

package/components/TS_MemoryMonitor/index.js

@@ -0,0 +1,21 @@
+/*
+ * Thunderstorm is a full web app framework!
+ *
+ * Typescript & Express backend infrastructure that natively runs on firebase function
+ * Typescript & React frontend infrastructure
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './TS_MemoryMonitor.js';

package/components/TS_MouseInteractivity/TS_PopUp/TS_PopUp.d.ts

@@ -0,0 +1,9 @@
+import './TS_PopUp.scss';
+import { OnWindowResized } from '../../../modules/ModuleFE_Window.js';
+import { TS_MouseInteractivity } from '../base/TS_MouseInteractivity.js';
+import { Model_PopUp, PopUpListener } from '../../../component-modules/mouse-interactivity/types.js';
+export declare class TS_PopUp extends TS_MouseInteractivity<Model_PopUp> implements PopUpListener, OnWindowResized {
+    __onWindowResized(): void;
+    __onPopUpDisplay: (model?: Model_PopUp) => void;
+    render(): "" | import("react/jsx-runtime").JSX.Element;
+}

package/components/TS_MouseInteractivity/TS_PopUp/TS_PopUp.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import './TS_PopUp.scss';
+import { TS_Overlay } from '../../TS_Overlay/index.js';
+import { _className, stopPropagation } from '../../../utils/tools.js';
+import { resolveContent } from '@nu-art/ts-common';
+import { TS_MouseInteractivity } from '../base/TS_MouseInteractivity.js';
+import { mouseInteractivity_PopUp } from '../../../component-modules/mouse-interactivity/types.js';
+import { ModuleFE_MouseInteractivity } from '../../../component-modules/mouse-interactivity/ModuleFE_MouseInteractivity.js';
+export class TS_PopUp extends TS_MouseInteractivity {
+    __onWindowResized() {
+        if (this.state.model)
+            ModuleFE_MouseInteractivity.hide(mouseInteractivity_PopUp);
+    }
+    __onPopUpDisplay = (model) => {
+        this.setState({ model, open: !!model });
+    };
+    render() {
+        const { model, open } = this.state;
+        if (!model || !open)
+            return '';
+        return _jsx(TS_Overlay, { className: _className('ts-popup', model.overlayClass), showOverlay: open, onClickOverlay: (e) => {
+                stopPropagation(e);
+                if (!model.ignoreOverlayClick || !resolveContent(model?.ignoreOverlayClick))
+                    this.setState({ open: false });
+                ModuleFE_MouseInteractivity.hide(mouseInteractivity_PopUp);
+            }, children: _jsx("div", { className: "ts-popup__content", id: model.id, ref: this.ref, onClick: stopPropagation, onContextMenu: stopPropagation, children: resolveContent(model.content, () => this.forceUpdate()) }) });
+    }
+}

package/components/TS_MouseInteractivity/TS_PopUp/TS_PopUp.scss

@@ -0,0 +1,53 @@
+/*!
+ * Thunderstorm is a full web app framework!
+ *
+ * Typescript & Express backend infrastructure that natively runs on firebase function
+ * Typescript & React frontend infrastructure
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+.ts-popup.ts-overlay {
+  z-index: 300;
+  background: #00000020;
+
+  .ts-overlay__child {
+    position: absolute;
+  }
+
+  .ts-popup__content {
+    z-index: 301;
+    cursor: default;
+    position: fixed;
+    overflow-x: hidden;
+    overflow-y: auto;
+    max-height: 60vh;
+    border-radius: 2px;
+    box-shadow: 1px 1px 4px 0 rgba(0, 0, 0, 0.3);
+    border: solid 1px transparent;
+    background-color: white;
+
+    .ts-popup__content__menu {
+      .ts-tree__node {
+        padding-inline: 10px;
+        white-space: nowrap;
+
+        &:hover {
+          background: cornsilk;
+        }
+      }
+    }
+  }
+}

package/components/TS_MouseInteractivity/TS_Tooltip/TS_ToolTip.d.ts

@@ -0,0 +1,12 @@
+import './TS_ToolTip.scss';
+import { TS_MouseInteractivity } from '../base/TS_MouseInteractivity.js';
+import { Model_ToolTip, ToolTipListener } from '../../../component-modules/mouse-interactivity/types.js';
+import { OnWindowResized } from '../../../modules/ModuleFE_Window.js';
+export declare class TS_ToolTip extends TS_MouseInteractivity<Model_ToolTip> implements OnWindowResized, ToolTipListener {
+    private timeout;
+    __onWindowResized: () => void;
+    __onToolTipDisplay: (model?: Model_ToolTip) => void;
+    private onContentMouseEnter;
+    private onContentMouseLeave;
+    render(): "" | import("react/jsx-runtime").JSX.Element;
+}

package/components/TS_MouseInteractivity/TS_Tooltip/TS_ToolTip.js

@@ -0,0 +1,65 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/*
+ * Thunderstorm is a full web app framework!
+ *
+ * Typescript & Express backend infrastructure that natively runs on firebase function
+ * Typescript & React frontend infrastructure
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import './TS_ToolTip.scss';
+import { TS_MouseInteractivity } from '../base/TS_MouseInteractivity.js';
+import { resolveContent } from '@nu-art/ts-common';
+import { mouseInteractivity_ToolTip } from '../../../component-modules/mouse-interactivity/types.js';
+import { ModuleFE_MouseInteractivity } from '../../../component-modules/mouse-interactivity/ModuleFE_MouseInteractivity.js';
+export class TS_ToolTip extends TS_MouseInteractivity {
+    timeout = undefined;
+    __onWindowResized = () => {
+        if (this.state.model?.id)
+            ModuleFE_MouseInteractivity.hide(mouseInteractivity_ToolTip);
+    };
+    __onToolTipDisplay = (model) => {
+        //Clear timeout if one exists
+        if (this.timeout)
+            clearTimeout(this.timeout);
+        //If a model is given
+        if (model)
+            return this.setState({ model, open: true });
+        //Model is not given
+        const allowContentHover = this.state.model?.contentHoverDelay;
+        if (allowContentHover)
+            this.timeout = setTimeout(() => {
+                this.setState({ model: undefined, open: false });
+            }, allowContentHover);
+        else
+            this.setState({ model: undefined, open: false });
+    };
+    onContentMouseEnter = () => {
+        if (!this.state.model?.contentHoverDelay)
+            return;
+        //Clear the timeout to stop hiding the content
+        if (this.timeout)
+            clearTimeout(this.timeout);
+    };
+    onContentMouseLeave = () => {
+        ModuleFE_MouseInteractivity.hide(mouseInteractivity_ToolTip);
+    };
+    render() {
+        const { model, open } = this.state;
+        if (!model || !open)
+            return '';
+        return _jsx("div", { className: 'ts-tooltip__content', id: model.id, ref: this.ref, onMouseEnter: this.onContentMouseEnter, onMouseLeave: this.onContentMouseLeave, onMouseMove: this.onContentMouseEnter, children: resolveContent(model.content, () => this.forceUpdate()) });
+    }
+}

package/components/TS_MouseInteractivity/TS_Tooltip/TS_ToolTip.scss

@@ -0,0 +1,46 @@
+/*!
+ * Thunderstorm is a full web app framework!
+ *
+ * Typescript & Express backend infrastructure that natively runs on firebase function
+ * Typescript & React frontend infrastructure
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+.ts-overlay.ts-tooltip {
+  z-index: 400;
+  background: #00000020;
+
+  .ts-overlay__child {
+    position: absolute;
+  }
+
+  &.transparent {
+    background: transparent;
+  }
+}
+
+.ts-tooltip__content {
+  z-index: 401;
+  cursor: default;
+  position: fixed;
+  overflow-x: hidden;
+  overflow-y: auto;
+  max-height: 60vh;
+  border-radius: 2px;
+  box-shadow: 1px 1px 4px 0 rgba(0, 0, 0, 0.3);
+  border: solid 1px transparent;
+  background-color: white;
+}

package/components/TS_MouseInteractivity/base/TS_MouseInteractivity.d.ts

@@ -0,0 +1,18 @@
+import * as React from 'react';
+import { MouseInteractivity_Model } from '../../../component-modules/mouse-interactivity/types.js';
+import { ComponentSync } from '../../../core/ComponentSync.js';
+type State<M extends MouseInteractivity_Model> = {
+    model?: M;
+    open: boolean;
+};
+type Prop = {};
+export declare class TS_MouseInteractivity<M extends MouseInteractivity_Model = MouseInteractivity_Model> extends ComponentSync<Prop, State<M>> {
+    protected ref: React.RefObject<HTMLDivElement>;
+    private minimumMargin;
+    protected deriveStateFromProps(nextProps: Prop, state: State<M>): State<M>;
+    componentDidUpdate(): void;
+    private setModalPosition;
+    private getDistancesFromViewPort;
+    private keepModalInView;
+}
+export {};

package/components/TS_MouseInteractivity/base/TS_MouseInteractivity.js

@@ -0,0 +1,100 @@
+import * as React from 'react';
+import { logicalXOR } from '@nu-art/ts-common';
+import { ComponentSync } from '../../../core/ComponentSync.js';
+export class TS_MouseInteractivity extends ComponentSync {
+    ref = React.createRef();
+    minimumMargin = 5;
+    deriveStateFromProps(nextProps, state) {
+        state.open ??= false;
+        return state;
+    }
+    componentDidUpdate() {
+        if (!this.state.model || !this.state.open)
+            return;
+        this.setModalPosition();
+        this.keepModalInView();
+    }
+    setModalPosition = () => {
+        const model = this.state.model;
+        const modalRect = this.ref.current.getBoundingClientRect();
+        const halfWidth = (modalRect.width / 2);
+        const halfHeight = (modalRect.height / 2);
+        const xAxisAnchor = model.xAxisAnchor ?? 'left';
+        const yAxisAnchor = model.yAxisAnchor ?? 'top';
+        //Start the modal centered on the trigger
+        const modalPosition = {
+            x: (xAxisAnchor === 'right' ? window.innerWidth - model.originPos.x : model.originPos.x) - halfWidth,
+            y: (yAxisAnchor === 'bottom' ? window.innerHeight - model.originPos.y : model.originPos.y) - halfHeight,
+        };
+        //Move the modal based on modalPos property
+        modalPosition.x += model.modalPos.x * (xAxisAnchor === 'right' ? -halfWidth : halfWidth);
+        modalPosition.y += model.modalPos.y * (yAxisAnchor === 'bottom' ? -halfHeight : halfHeight);
+        //Add offsets to modal
+        modalPosition.x += model.offset?.x || 0;
+        modalPosition.y += model.offset?.y || 0;
+        //Set position
+        this.ref.current.style[yAxisAnchor] = `${modalPosition.y}px`;
+        this.ref.current.style[xAxisAnchor] = `${modalPosition.x}px`;
+    };
+    getDistancesFromViewPort = () => {
+        const rect = this.ref.current.getBoundingClientRect();
+        return {
+            top: rect.top,
+            left: rect.left,
+            right: window.innerWidth - rect.right,
+            bottom: window.innerHeight - rect.bottom
+        };
+    };
+    keepModalInView = () => {
+        const distances = this.getDistancesFromViewPort();
+        const current = this.ref.current;
+        const rect = current.getBoundingClientRect();
+        const offset = { x: 0, y: 0 };
+        const xAxisAnchor = this.state.model.xAxisAnchor ?? 'left';
+        const yAxisAnchor = this.state.model.yAxisAnchor ?? 'top';
+        //Fix vertical axis if only one side is overflowing
+        if (logicalXOR(distances.bottom < this.minimumMargin, distances.top < this.minimumMargin)) {
+            //If bottom is overflowing
+            if (distances.bottom < this.minimumMargin) {
+                const correction = distances.bottom - this.minimumMargin;
+                //If correction doesn't cause top to overflow
+                if (distances.top + correction >= this.minimumMargin)
+                    offset.y = correction;
+            }
+            else { //Top is overflowing
+                const correction = -distances.top + this.minimumMargin;
+                //If correction doesn't cause bottom to overflow
+                if (distances.bottom - correction >= this.minimumMargin)
+                    offset.y = correction;
+            }
+        }
+        //Fix horizontal axis if only one side is overflowing
+        if (logicalXOR(distances.right < this.minimumMargin, distances.left < this.minimumMargin)) {
+            //If right is overflowing
+            if (distances.right < this.minimumMargin) {
+                const correction = distances.right - this.minimumMargin;
+                //If correction doesn't cause left to overflow
+                if (distances.left + correction >= this.minimumMargin)
+                    offset.x = correction;
+            }
+            else { //Left is overflowing
+                const correction = -distances.left + this.minimumMargin;
+                //If correction doesn't cause right to overflow
+                if (distances.right - correction >= this.minimumMargin)
+                    offset.x = correction;
+            }
+        }
+        if (offset.y) {
+            if (yAxisAnchor === 'top')
+                current.style.top = `${rect.top + offset.y}px`;
+            else
+                current.style.bottom = `${rect.bottom - offset.y}px`;
+        }
+        if (offset.x) {
+            if (xAxisAnchor === 'left')
+                current.style.left = `${rect.left + offset.x}px`;
+            else
+                current.style.right = `${rect.right - offset.x}px`;
+        }
+    };
+}

package/components/TS_MouseInteractivity/index.d.ts

@@ -0,0 +1,2 @@
+export * from './TS_Tooltip/TS_ToolTip.js';
+export * from './TS_PopUp/TS_PopUp.js';

package/components/TS_MouseInteractivity/index.js

@@ -0,0 +1,22 @@
+/*
+ * Thunderstorm is a full web app framework!
+ *
+ * Typescript & Express backend infrastructure that natively runs on firebase function
+ * Typescript & React frontend infrastructure
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './TS_Tooltip/TS_ToolTip.js';
+export * from './TS_PopUp/TS_PopUp.js';

package/components/TS_MultiSelect/TS_MultiSelect.scss

@@ -0,0 +1,34 @@
+.frame-layout {
+  width: 100%;
+  height: 100%;
+  position: relative;
+
+}
+
+@mixin tag($lightColor,$darkColor) {
+  background: $lightColor;
+  border: 1px solid $darkColor;
+  border-radius: 5px;
+  min-width: 70px;
+  height: 28px;
+  padding-block: 4px;
+  padding-inline: 8px;
+  flex-shrink: 0;
+}
+
+.ts-multi-select__list {
+  gap: 12px;
+  width: 100%;
+
+  &.ll_h_c {
+    flex-wrap: wrap;
+  }
+
+  .ts-multi-select__value {
+    @include tag(var(--tags--inner-color), var(--tags--outer-color));
+
+    .ts-icon__small {
+      margin-right: 4px;
+    }
+  }
+}

package/components/TS_MultiSelect/TS_MultiSelect_V2.d.ts

@@ -0,0 +1,36 @@
+import * as React from 'react';
+import { Component, ReactNode } from 'react';
+import { SubsetKeys } from '@nu-art/ts-common';
+import './TS_MultiSelect.scss';
+import { EditableItem } from '../../utils/EditableItem.js';
+type Binder_MultiSelect<EnclosingItem, K extends keyof EnclosingItem, ExpectedType> = EnclosingItem[K] extends ExpectedType[] ? {
+    EnclosingItem: EnclosingItem;
+    Prop: K;
+    InnerType: ExpectedType;
+} : never;
+export type DynamicProps_TS_MultiSelect_V2<EnclosingItem, Prop extends keyof EnclosingItem> = {
+    editable: EditableItem<EnclosingItem>;
+    prop: Prop;
+    disabled?: boolean;
+};
+export type StaticProps_TS_MultiSelect_V2<ItemType> = {
+    className?: string;
+    itemsDirection?: 'vertical' | 'horizontal';
+    selectionFilter?: (item: ItemType) => boolean;
+    itemFilter?: (item: ItemType) => boolean;
+    sort?: (items: ItemType[]) => ItemType[];
+    itemRenderer: (item?: ItemType, onDelete?: () => Promise<void>, disabled?: boolean) => ReactNode;
+    selectionRenderer: React.ComponentType<MultiSelect_Selector<ItemType>>;
+};
+export type Props_TS_MultiSelect_V2<Binder extends Binder_MultiSelect<any, any, any>> = StaticProps_TS_MultiSelect_V2<Binder['InnerType']> & DynamicProps_TS_MultiSelect_V2<Binder['EnclosingItem'], Binder['Prop']>;
+export type MultiSelect_Selector<ItemType> = {
+    className: string;
+    existingItems: ItemType[];
+    onSelected: (selected: ItemType) => void | Promise<void>;
+    queryFilter?: (item: ItemType) => boolean;
+};
+export declare class TS_MultiSelect_V2<Binder extends Binder_MultiSelect<any, any, any>> extends Component<Props_TS_MultiSelect_V2<Binder>, any> {
+    static prepare<EnclosingItem, K extends keyof EnclosingItem, InnerType>(_props: StaticProps_TS_MultiSelect_V2<InnerType>): <EnclosingItem_, Prop extends SubsetKeys<keyof EnclosingItem_, EnclosingItem_, InnerType[] | undefined>>(props: DynamicProps_TS_MultiSelect_V2<EnclosingItem_, Prop> & Partial<StaticProps_TS_MultiSelect_V2<InnerType>>) => import("react/jsx-runtime").JSX.Element;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export {};

package/components/TS_MultiSelect/TS_MultiSelect_V2.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Component } from 'react';
+import './TS_MultiSelect.scss';
+import { LL_H_C, LL_V_L } from '../Layouts/index.js';
+import { _className } from '../../utils/tools.js';
+export class TS_MultiSelect_V2 extends Component {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    static prepare(_props) {
+        return (props) => _jsx(TS_MultiSelect_V2, { ..._props, ...props });
+    }
+    render() {
+        const editable = this.props.editable;
+        const prop = this.props.prop;
+        const editableProp = editable.editProp(prop, []);
+        const existingItems = editableProp.item;
+        let itemsToRender = this.props.selectionFilter ? existingItems.filter(this.props.selectionFilter) : existingItems;
+        if (this.props.sort)
+            itemsToRender = this.props.sort(itemsToRender);
+        const addInnerItem = async (item) => {
+            await editableProp.updateArrayAt(item);
+            this.forceUpdate();
+        };
+        const props = this.props;
+        const SelectionRenderer = props.selectionRenderer;
+        const direction = this.props.itemsDirection ?? 'horizontal';
+        const Wrapper = direction === 'horizontal' ? LL_H_C : LL_V_L;
+        const className = _className('ts-multi-select__list', this.props.disabled && 'disabled', this.props.className);
+        return _jsxs(Wrapper, { className: className, children: [itemsToRender.map((item, i) => {
+                    return _jsx(LL_H_C, { className: "ts-multi-select__list-value", children: props.itemRenderer(item, async () => {
+                            const index = existingItems.indexOf(item);
+                            await editableProp.removeArrayItem(index);
+                            this.forceUpdate();
+                        }, this.props.disabled) }, i);
+                }), !this.props.disabled && SelectionRenderer({
+                    className: 'ts-multi-select__selector',
+                    onSelected: addInnerItem,
+                    existingItems: existingItems,
+                    queryFilter: this.props.itemFilter
+                })] });
+    }
+}

package/components/TS_MultiSelect/index.d.ts

@@ -0,0 +1 @@
+export * from './TS_MultiSelect_V2.js';

package/components/TS_MultiSelect/index.js

@@ -0,0 +1,21 @@
+/*
+ * Thunderstorm is a full web app framework!
+ *
+ * Typescript & Express backend infrastructure that natively runs on firebase function
+ * Typescript & React frontend infrastructure
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './TS_MultiSelect_V2.js';

package/components/TS_Notifications/TS_Notifications.d.ts

@@ -0,0 +1,22 @@
+import { ComponentSync } from '../../core/ComponentSync.js';
+import { DB_Notification, NotificationListener } from '../../component-modules/ModuleFE_Notifications.js';
+import './TS_Notifications.scss';
+type State = {
+    notifications: DB_Notification[];
+    showNotifications: boolean;
+};
+export declare class TS_Notifications extends ComponentSync<{}, State> implements NotificationListener {
+    private overlayClass;
+    private containerClass;
+    private transitionTimeout;
+    private timeout;
+    __showNotifications(notifications: DB_Notification[]): void;
+    protected deriveStateFromProps(nextProps: any): State;
+    private onClickToClose;
+    private deletePost;
+    private onNotificationClick;
+    private renderNotification;
+    private renderNotifications;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export {};