@nu-art/thunderstorm-frontend 0.400.5

package/components/TS_Toggle/TS_Toggle.d.ts

@@ -0,0 +1,21 @@
+import { ComponentSync } from '../../core/ComponentSync.js';
+import './TS_Toggle.scss';
+type Props = {
+    id?: string;
+    checked: boolean;
+    onCheck: (status: boolean) => void;
+    disabled?: boolean;
+    containerClassName?: string;
+    sliderClassName?: string;
+};
+type State = {
+    id: string;
+    checked: boolean;
+    disabled?: boolean;
+};
+export declare class TS_Toggle extends ComponentSync<Props, State> {
+    protected deriveStateFromProps(nextProps: Props, state: State): State;
+    private updateCheckedStatus;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export {};

package/components/TS_Toggle/TS_Toggle.js

@@ -0,0 +1,26 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ComponentSync } from '../../core/ComponentSync.js';
+import { _className } from '../../utils/tools.js';
+import './TS_Toggle.scss';
+import { generateHex, voidFunction } from '@nu-art/ts-common';
+export class TS_Toggle extends ComponentSync {
+    deriveStateFromProps(nextProps, state) {
+        state.checked = nextProps.checked;
+        state.disabled = nextProps.disabled;
+        state.id ??= nextProps.id ?? generateHex(4);
+        return state;
+    }
+    updateCheckedStatus = (e) => {
+        // fail fast if disabled
+        if (this.state.disabled)
+            return;
+        // we can assume that knowing the structure of this component
+        const checkboxElement = e.currentTarget.children[0];
+        return this.props.onCheck(checkboxElement.checked);
+    };
+    render() {
+        const containerClassName = _className('ts-toggle', this.state.disabled && 'disabled', this.props.containerClassName);
+        const sliderClassName = _className('ts-toggle__slider', this.state.disabled && 'disabled', this.props.sliderClassName);
+        return _jsxs("div", { id: this.state.id, onClick: this.updateCheckedStatus, className: containerClassName, children: [_jsx("input", { onChange: voidFunction, className: 'ts-toggle__checkbox', type: 'checkbox', checked: this.state.checked }), _jsx("label", { htmlFor: this.state.id, className: sliderClassName })] });
+    }
+}

package/components/TS_Toggle/TS_Toggle.scss

@@ -0,0 +1,56 @@
+.ts-toggle {
+  height: 20px;
+  width: 40px;
+
+  .ts-toggle__slider {
+    position: relative;
+
+    &:before,
+    &:after {
+      cursor: pointer;
+      bottom: 0;
+      content: '';
+      display: inline-block;
+      margin: auto;
+    }
+
+    /* ellipse */
+    &:before {
+      box-shadow: 2px 2px 4px 0 #E0E0E05F inset;
+      transition: background-color 300ms ease-out;
+      background-color: #fff;
+      border-radius: 50px;
+      top: 0;
+      height: 20px;
+      width: 40px;
+    }
+
+    /* circle */
+    &:after {
+      background-color: #e0e0e0;
+      border-radius: 50%;
+      position: absolute;
+      top: -10px;
+      height: 15px;
+      left: 2px;
+      transition: all 300ms ease-out;
+      width: 15px;
+    }
+
+    &.disabled {
+      cursor: not-allowed;
+    }
+  }
+
+  .ts-toggle__checkbox {
+    display: none;
+
+    &:checked ~ .ts-toggle__slider:before {
+      background-color: #fff;
+    }
+
+    &:checked ~ .ts-toggle__slider:after {
+      transform: translateX(20px);
+    }
+  }
+}

package/components/TS_Toggle/index.d.ts

@@ -0,0 +1,2 @@
+export * from './ATS_Toggle.js';
+export * from './TS_Toggle.js';

package/components/TS_Toggle/index.js

@@ -0,0 +1,2 @@
+export * from './ATS_Toggle.js';
+export * from './TS_Toggle.js';

package/components/TS_Toggler/TS_Toggler.d.ts

@@ -0,0 +1,23 @@
+import { ComponentSync } from '../../core/ComponentSync.js';
+import './TS_Toggler.scss';
+type Props<T> = {
+    options: [T, T];
+    defaultValue?: T;
+    value?: T;
+    onValueChange?: (value: T | undefined) => void | Promise<void>;
+    disabled?: boolean;
+    alwaysSelected?: boolean;
+};
+type State<T> = {
+    value: T | undefined;
+    disabled?: boolean;
+};
+export declare class TS_Toggler<T extends number | string = number | string> extends ComponentSync<Props<T>, State<T>> {
+    protected deriveStateFromProps(nextProps: Props<T>): State<T>;
+    private onValueChange;
+    private cycleToggler;
+    private renderButton;
+    private renderOption;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export {};

package/components/TS_Toggler/TS_Toggler.js

@@ -0,0 +1,50 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ComponentSync } from '../../core/ComponentSync.js';
+import { LL_H_C } from '../Layouts/index.js';
+import { _className } from '../../utils/tools.js';
+import './TS_Toggler.scss';
+export class TS_Toggler extends ComponentSync {
+    deriveStateFromProps(nextProps) {
+        const state = {};
+        //First derive
+        if (!this.state)
+            state.value = this.props.defaultValue;
+        else
+            state.value = this.props.value || this.state.value;
+        if (!state.value && nextProps.alwaysSelected)
+            state.value = nextProps.options[0];
+        state.disabled = nextProps.disabled;
+        return state;
+    }
+    onValueChange = (value) => {
+        const _value = value === this.state.value && !this.props.alwaysSelected ? undefined : value;
+        this.props.onValueChange?.(_value);
+        this.setState({ value: _value });
+        this.reDeriveState();
+    };
+    cycleToggler = () => {
+        const options = this.props.options;
+        const currentOptionIndex = options.findIndex((value, index) => value === this.state.value);
+        const nextValue = options.length - 1 > currentOptionIndex ? options[currentOptionIndex + 1]
+            : this.props.alwaysSelected ? options[0]
+                : undefined;
+        this.onValueChange(nextValue);
+    };
+    renderButton = () => {
+        let buttonDir = undefined;
+        if (this.state.value === this.props.options[0])
+            buttonDir = 'left';
+        if (this.state.value === this.props.options[1])
+            buttonDir = 'right';
+        const buttonClassName = _className('ts-toggler__toggler-button', buttonDir);
+        return _jsx("div", { className: 'ts-toggler__toggler', onClick: () => !this.props.disabled && this.cycleToggler(), children: _jsx("div", { className: buttonClassName }) });
+    };
+    renderOption = (option) => {
+        const className = _className('ts-toggler__option', option === this.state?.value ? 'active' : undefined);
+        return _jsx("span", { className: className, onClick: () => !this.props.disabled && this.onValueChange(option), children: option });
+    };
+    render() {
+        const className = _className('ts-toggler', this.state.disabled ? 'disabled' : undefined);
+        return _jsxs(LL_H_C, { className: className, children: [this.renderOption(this.props.options[0]), this.renderButton(), this.renderOption(this.props.options[1])] });
+    }
+}

package/components/TS_Toggler/TS_Toggler.scss

@@ -0,0 +1,83 @@
+$disabledColor: #DBDBDB;
+$buttonColor: #00A5F6;
+$borderColor: #8A959B;
+
+.ts-toggler {
+  flex-shrink: 0;
+  gap: 10px;
+
+  .ts-toggler__option {
+    font-size: 14px;
+    color: black;
+    cursor: pointer;
+
+
+    &:first-child {
+      padding-left: 4px;
+      text-align: right;
+    }
+
+    &:last-child {
+      padding-right: 4px;
+      text-align: left;
+    }
+
+    &.active {
+      font-weight: bold;
+      padding: 0;
+    }
+  }
+
+  .ts-toggler__toggler {
+    //Size
+    width: 44px;
+    height: 20px;
+
+    //Position & Display
+    position: relative;
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    cursor: pointer;
+
+    //Border
+    border-radius: 10px;
+    border: 2px solid $borderColor;
+
+    //Button
+    .ts-toggler__toggler-button {
+      background: $buttonColor;
+      width: 10px;
+      height: 10px;
+      border-radius: 50%;
+      transition: translate 100ms ease-in-out;
+
+      &.left {
+        translate: -10px;
+      }
+
+      &.right {
+        translate: 10px;
+      }
+    }
+  }
+
+  &.disabled {
+    .ts-toggler__option {
+      color: $disabledColor;
+      cursor: not-allowed;
+    }
+
+    .ts-toggler__toggler {
+      //Border
+      border: 2px solid $disabledColor;
+      cursor: not-allowed;
+
+      //Button
+      .ts-toggler__toggler-button {
+        background: $disabledColor;
+        translate: 0;
+      }
+    }
+  }
+}

package/components/TS_Toggler/index.d.ts

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

package/components/TS_Toggler/index.js

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

package/components/TS_Tree/SimpleTreeNodeRenderer.d.ts

@@ -0,0 +1,9 @@
+import * as React from 'react';
+import { BaseNodeRenderer, NodeRendererProps } from '../adapter/BaseRenderer.js';
+export declare class SimpleTreeNodeRenderer extends BaseNodeRenderer<any> {
+    renderCollapse(): import("react/jsx-runtime").JSX.Element;
+    protected renderItem(item: any): React.ReactNode;
+}
+export declare class SimpleNodeRenderer extends React.Component<NodeRendererProps> {
+    render(): string;
+}

package/components/TS_Tree/SimpleTreeNodeRenderer.js

@@ -0,0 +1,53 @@
+import { jsx as _jsx, jsxs as _jsxs } 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 * as React from 'react';
+import { BaseNodeRenderer } from '../adapter/BaseRenderer.js';
+export class SimpleTreeNodeRenderer extends BaseNodeRenderer {
+    renderCollapse() {
+        let toDisplay;
+        if (typeof this.props.item !== 'object')
+            toDisplay = '';
+        else if (Object.keys(this.props.item).length === 0)
+            toDisplay = '';
+        else if (this.props.node.expanded)
+            toDisplay = '-';
+        else
+            toDisplay = '+';
+        return _jsx("div", { className: `clickable`, style: { width: '15px' }, children: toDisplay });
+    }
+    renderItem(item) {
+        return (_jsxs("div", { className: "ll_h_c", children: [this.renderCollapse(), _jsx(SimpleNodeRenderer, { ...this.props })] }));
+    }
+}
+export class SimpleNodeRenderer extends React.Component {
+    render() {
+        let label;
+        const item = this.props.item;
+        if (typeof item !== 'object')
+            label = ` : ${item}`;
+        else if (Object.keys(item).length === 0)
+            label = ' : {}';
+        else
+            label = '';
+        return ('propKey') + label;
+    }
+}

package/components/TS_Tree/TS_Tree.d.ts

@@ -0,0 +1,68 @@
+import * as React from 'react';
+import { CSSProperties } from 'react';
+import { Adapter } from '../adapter/Adapter.js';
+import './TS_Tree.scss';
+import { ComponentSync } from '../../core/ComponentSync.js';
+import { TreeNodeExpandState } from './types.js';
+export type Props_Tree = {
+    id: string;
+    onNodeFocused?: (path: string, item: any) => void;
+    onNodeClicked?: (path: string, item: any) => void;
+    onContextMenuClicked?: (e: React.MouseEvent, path: string, item: any) => void;
+    expanded?: TreeNodeExpandState;
+    checkExpanded: (expanded: TreeNodeExpandState, path: string, nodeData: any) => boolean | undefined;
+    className?: string;
+    treeContainerStyle?: CSSProperties;
+    selectedItem?: any;
+    isSelected?: (item: any) => boolean;
+    indexTreeNodes?: boolean;
+    selectedPath?: string;
+    adapter: Adapter;
+    startTreeOpen?: boolean;
+    containerRef?: React.RefObject<any>;
+    scrollSelectedIntoView?: boolean;
+};
+type State_Tree = {
+    expanded: TreeNodeExpandState;
+    isSelected?: (item: any) => boolean;
+    selected: {
+        path?: string;
+        item?: (item: any) => boolean;
+    };
+    adapter: Adapter;
+};
+export declare class TS_Tree<P extends Props_Tree = Props_Tree, S extends State_Tree = State_Tree> extends ComponentSync<P, State_Tree> {
+    static defaultProps: Partial<Props_Tree>;
+    protected containerRefs: {
+        [k: string]: HTMLDivElement;
+    };
+    protected rendererRefs: {
+        [k: string]: HTMLDivElement;
+    };
+    constructor(props: P);
+    shouldComponentUpdate(nextProps: Readonly<P>, nextState: Readonly<State_Tree>, nextContext: any): boolean;
+    protected deriveStateFromProps(nextProps: P): {
+        adapter: Adapter<any, import("../adapter/BaseRenderer.js").NodeRendererProps<any>>;
+        expanded: TreeNodeExpandState;
+        isSelected: ((item: any) => boolean) | undefined;
+        selected: {
+            path: string | undefined;
+            item: any;
+        };
+    };
+    componentDidUpdate(): void;
+    private onNodeClicked;
+    private onContextMenuClicked;
+    private nodeResolver;
+    private resolveContainer;
+    getItemByPath(path: string): any;
+    static resolveItemFromPath(data: any, path?: string): any;
+    private toggleExpandState;
+    private expandOrCollapse;
+    private resolveTreeNode;
+    private renderNode;
+    private renderChildren;
+    private renderItem;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export {};

package/components/TS_Tree/TS_Tree.js

@@ -0,0 +1,174 @@
+import { jsxs as _jsxs, jsx as _jsx } from "react/jsx-runtime";
+import { Fragment } from 'react';
+import { _className } from '../../utils/tools.js';
+import './TS_Tree.scss';
+import { ComponentSync } from '../../core/ComponentSync.js';
+import { _keys, exists } from '@nu-art/ts-common';
+const ignoreToggler = () => {
+};
+export class TS_Tree extends ComponentSync {
+    // ######################## Static ########################
+    static defaultProps = {
+        checkExpanded: (expanded, path) => expanded[path]
+    };
+    containerRefs = {};
+    rendererRefs = {};
+    // ######################## Life Cycle ########################
+    constructor(props) {
+        super(props);
+    }
+    shouldComponentUpdate(nextProps, nextState, nextContext) {
+        return true;
+    }
+    deriveStateFromProps(nextProps) {
+        return {
+            adapter: nextProps.adapter,
+            expanded: nextProps.expanded ?? this.state?.expanded ?? { '/': nextProps.startTreeOpen ?? true },
+            isSelected: nextProps.isSelected,
+            selected: {
+                path: nextProps.selectedPath,
+                item: nextProps.selectedItem
+            }
+        };
+    }
+    componentDidUpdate() {
+        if (!this.props.scrollSelectedIntoView || !(this.state.selected?.item || this.state.selected?.path) || !this.props.containerRef?.current)
+            return;
+        const itemPath = this.state.selected.path ?? _keys(this.rendererRefs).find(key => this.getItemByPath(key) === this.state.selected.item);
+        const childRect = this.rendererRefs[itemPath].getBoundingClientRect();
+        const containerRect = this.props.containerRef.current.getBoundingClientRect();
+        const inView = (childRect.top >= containerRect.top) && (childRect.bottom <= containerRect.top + this.props.containerRef.current.clientHeight);
+        if (!inView) {
+            const scrollTop = childRect.top - containerRect.top;
+            const scrollBot = childRect.bottom - containerRect.bottom;
+            let scroll = this.props.containerRef.current.scrollTop;
+            if (Math.abs(scrollTop) < Math.abs(scrollBot))
+                scroll += scrollTop;
+            else
+                scroll += scrollBot;
+            this.props.containerRef.current.scroll({ top: scroll });
+        }
+    }
+    // ######################## Logic ########################
+    onNodeClicked = (e) => {
+        const path = e.currentTarget.getAttribute('data-path');
+        if (!path)
+            return this.logError('No Path for tree node:', e);
+        //FIXME: consider typing the return from resolveItemFromPath instead of limiting the return to just the item
+        this.props.onNodeClicked?.(path, TS_Tree.resolveItemFromPath(this.state.adapter.data, path));
+    };
+    onContextMenuClicked = (e) => {
+        const path = e.currentTarget.getAttribute('data-path');
+        if (!path)
+            return this.logError('No Path for tree node:', e);
+        //FIXME: consider typing the return from resolveItemFromPath instead of limiting the return to just the item
+        this.props.onContextMenuClicked?.(e, path, TS_Tree.resolveItemFromPath(this.state.adapter.data, path));
+    };
+    nodeResolver(nodePath, renderChildren, filteredKeys) {
+        return (_ref) => {
+            if (this.rendererRefs[nodePath])
+                return;
+            this.rendererRefs[nodePath] = _ref;
+            if (this.containerRefs[nodePath] && renderChildren && filteredKeys.length > 0)
+                this.forceUpdate();
+        };
+    }
+    resolveContainer(nodePath, renderChildren, filteredKeys) {
+        return (_ref) => {
+            if (this.containerRefs[nodePath])
+                return;
+            this.containerRefs[nodePath] = _ref;
+            if (renderChildren && filteredKeys.length > 0)
+                this.forceUpdate();
+        };
+    }
+    getItemByPath(path) {
+        return TS_Tree.resolveItemFromPath(this.state.adapter.data, path);
+    }
+    static resolveItemFromPath(data, path) {
+        if (!path)
+            return;
+        let item = data;
+        const hierarchy = path.split('/');
+        hierarchy.shift();
+        for (const el of hierarchy) {
+            if (el) {
+                item = item[el];
+                if (!item)
+                    return;
+            }
+        }
+        return item;
+    }
+    toggleExpandState = (e, _expanded) => this.expandOrCollapse(this.resolveTreeNode(e.currentTarget), _expanded);
+    expandOrCollapse = (path, forceExpandState) => {
+        if (path === '/' && this.state.adapter.hideRoot && forceExpandState === false)
+            return;
+        const treeExpandedState = this.state.expanded;
+        const currentExpandState = treeExpandedState[path];
+        const newExpandState = exists(forceExpandState) ? forceExpandState : !currentExpandState;
+        if (newExpandState)
+            treeExpandedState[path] = newExpandState;
+        else
+            delete treeExpandedState[path];
+        this.forceUpdate();
+    };
+    resolveTreeNode(currentTarget) {
+        if (!currentTarget) {
+            this.logError('Could not find node!!');
+            return '';
+        }
+        if (!currentTarget.getAttribute('data-path'))
+            return this.resolveTreeNode(currentTarget.parentElement || undefined);
+        return currentTarget.getAttribute('data-path') || '';
+    }
+    // ######################## Render ########################
+    renderNode = (_data, key, _path, level) => {
+        const nodePath = `${_path}${key}/`;
+        const adjustedNode = this.state.adapter.adjust(_data);
+        const data = adjustedNode.data;
+        let filteredKeys = [];
+        const alwaysExpanded = exists(_data) && typeof _data === 'object' && _data.alwaysExpanded;
+        let expanded = alwaysExpanded || !!this.props.checkExpanded(this.state.expanded, nodePath, data);
+        if (nodePath.endsWith('_children/'))
+            expanded = true;
+        let renderChildren = expanded;
+        if (typeof data !== 'object')
+            renderChildren = false;
+        if (renderChildren)
+            filteredKeys = this.state.adapter.getFilteredChildren(_data);
+        const nodeRefResolver = this.nodeResolver(nodePath, renderChildren, filteredKeys);
+        const containerRefResolver = this.resolveContainer(nodePath, renderChildren, filteredKeys);
+        const isSelected = this.state.isSelected?.(_data) || _data === this.state.selected.item;
+        return _jsxs(Fragment, { children: [this.renderItem(data, nodePath, key, nodeRefResolver, level, isSelected, expanded), this.renderChildren(data, nodePath, _path, level, filteredKeys, renderChildren, adjustedNode, containerRefResolver)] }, nodePath);
+    };
+    renderChildren(data, nodePath, _path, level, filteredKeys, renderChildren, adjustedNode, containerRefResolver) {
+        if (!(filteredKeys.length > 0 && renderChildren))
+            return;
+        const containerRef = this.containerRefs[nodePath];
+        return (_jsx("div", { className: "ts-tree__children-container", ref: containerRefResolver, children: containerRef && filteredKeys.map((childKey) => this.renderNode(data[childKey], childKey, nodePath + (adjustedNode.deltaPath ? adjustedNode.deltaPath + '/' : ''), level + 1)) }));
+    }
+    renderItem(item, path, key, nodeRefResolver, level, isSelected, expanded) {
+        if (this.state.adapter.hideRoot && path.length === 1)
+            return null;
+        const TreeNodeRenderer = this.state.adapter.treeNodeRenderer;
+        // console.log("isParent: ", this.state.adapter.isParent(item));
+        const isParent = this.state.adapter.isParent(item);
+        const node = {
+            adapter: this.state.adapter,
+            propKey: key,
+            path,
+            item,
+            expandToggler: isParent ? this.toggleExpandState : ignoreToggler,
+            expandFromNode: expand => this.expandOrCollapse(path, expand),
+            expanded: !!expanded,
+        };
+        if (this.state.adapter.childrenKey === key)
+            return null;
+        const className = _className('ts-tree__node', isParent && 'ts-tree__parent-node', isSelected && 'ts-tree__selected-node', `depth-${level}`);
+        return _jsx("div", { tabIndex: this.props.indexTreeNodes ? 1 : undefined, "data-path": path, className: className, ref: nodeRefResolver, onClick: this.onNodeClicked, onContextMenu: this.onContextMenuClicked, children: _jsx(TreeNodeRenderer, { item: item, node: node }) });
+    }
+    render() {
+        return _jsx("div", { className: _className('ts-tree', this.props.className), style: this.props.treeContainerStyle, children: this.renderNode(this.state.adapter.data, '', '', (this.state.adapter.hideRoot ? -1 : 0)) });
+    }
+}

package/components/TS_Tree/TS_Tree.scss

@@ -0,0 +1,44 @@
+/*!
+ * 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.
+ */
+@use '../../styles/declaration/mixins' as *;
+
+.ts-tree {
+  .ts-tree__children-container {
+
+  }
+
+  .ts-tree__node {
+    padding: 4px 0;
+    @include spaces(12);
+
+    &:hover {
+      background: cornsilk;
+    }
+  }
+
+  .ts-tree__selected-node {
+    background: cornsilk;
+  }
+
+  .ts-tree__parent-node {
+
+  }
+}

package/components/TS_Tree/index.d.ts

@@ -0,0 +1,3 @@
+export * from './SimpleTreeNodeRenderer.js';
+export * from './types.js';
+export * from './TS_Tree.js';

package/components/TS_Tree/index.js

@@ -0,0 +1,23 @@
+/*
+ * 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 './SimpleTreeNodeRenderer.js';
+export * from './types.js';
+export * from './TS_Tree.js';

package/components/TS_Tree/types.d.ts

@@ -0,0 +1,4 @@
+export type NodeExpandCondition = (key: string, value: any, level: number, path: string) => boolean | undefined;
+export type TreeNodeExpandState = {
+    [path: string]: true | undefined;
+};