@1771technologies/lytenyte-pro 1.0.20 → 2.0.0-dev.1

package/dist/components/column-manager/column-manager.js

@@ -0,0 +1,47 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { TreeView } from "../tree-view/index.js";
+import { Checkbox } from "../checkbox/checkbox.js";
+export function ColumnManager({ columns, base, onColumnsChange, endElement, }) {
+    const items = useMemo(() => {
+        return columns.map((x) => ({ id: x.id, path: x.groupPath ?? [], name: x.name, column: x }));
+    }, [columns]);
+    return (_jsx(TreeView, { items: items, rowSelectionEnabled: false, draggable: true, rowHeight: 30, rowSelectAllShow: false, defaultExpansion: true, onItemsReordered: (x) => {
+            const columns = x.map((x) => x.column);
+            onColumnsChange(columns);
+        }, children: ({ row, leafs, toggle, dragProps, isOver, isBefore }) => {
+            const depth = row.depth;
+            const items = leafs();
+            const end = endElement?.({ columns: items.map((x) => x.column), row });
+            const isSelected = items.every((x) => !(x.column.hide ?? base?.hide));
+            const isIndeterminate = !isSelected && items.some((x) => !(x.column.hide ?? base?.hide));
+            const draggable = !!dragProps.draggable;
+            const checkbox = (_jsx(Checkbox, { checked: isSelected, indeterminate: isIndeterminate, onChange: () => {
+                    if (isSelected) {
+                        onColumnsChange(columns.map((x) => {
+                            const c = items.find((c) => x.id === c.column.id);
+                            if (!c)
+                                return x;
+                            return { ...c.column, hide: true };
+                        }));
+                    }
+                    else {
+                        onColumnsChange(columns.map((x) => {
+                            const c = items.find((c) => x.id === c.column.id);
+                            if (!c)
+                                return x;
+                            return { ...c.column, hide: false };
+                        }));
+                    }
+                } }));
+            if (row.kind === "branch")
+                return (_jsxs("div", { "data-ln-tree-view-cell": row.kind, "data-ln-tree-view-cell-expanded": row.kind === "branch" && row.expanded, "data-ln-tree-view-cell-expandable": row.kind === "branch" ? row.expandable : undefined, "data-ln-tree-over": isOver, "data-ln-tree-before": isBefore, style: { "--ln-row-depth": depth }, ...dragProps, children: [row.kind === "branch" && row.expandable && (_jsx("button", { "data-ln-tree-view-cell-expander": true, "aria-label": "toggle the row group expansion state", onClick: () => toggle(), children: !row.loadingGroup && _jsx(CaretRight, {}) })), draggable && (_jsx("div", { children: _jsx(DragDots, {}) })), checkbox, _jsx("div", { style: { flex: "1" }, children: row.key }), end] }));
+            return (_jsxs("div", { "data-ln-tree-view-cell": row.kind, "data-ln-tree-over": isOver, "data-ln-tree-before": isBefore, style: { "--ln-row-depth": depth }, ...dragProps, children: [draggable && (_jsx("div", { children: _jsx(DragDots, {}) })), checkbox, _jsx("div", { style: { flex: "1" }, children: row.data.name ?? row.data.id }), end] }));
+        } }));
+}
+function CaretRight() {
+    return (_jsx("svg", { xmlns: "http://www.w3.org/2000/svg", width: "16", height: "16", fill: "currentcolor", viewBox: "0 0 256 256", children: _jsx("path", { d: "M181.66,133.66l-80,80A8,8,0,0,1,88,208V48a8,8,0,0,1,13.66-5.66l80,80A8,8,0,0,1,181.66,133.66Z" }) }));
+}
+function DragDots() {
+    return (_jsx("svg", { xmlns: "http://www.w3.org/2000/svg", width: "16", height: "16", fill: "currentcolor", viewBox: "0 0 256 256", children: _jsx("path", { d: "M104,60A12,12,0,1,1,92,48,12,12,0,0,1,104,60Zm60,12a12,12,0,1,0-12-12A12,12,0,0,0,164,72ZM92,116a12,12,0,1,0,12,12A12,12,0,0,0,92,116Zm72,0a12,12,0,1,0,12,12A12,12,0,0,0,164,116ZM92,184a12,12,0,1,0,12,12A12,12,0,0,0,92,184Zm72,0a12,12,0,1,0,12,12A12,12,0,0,0,164,184Z" }) }));
+}

package/dist/components/external/clsx.d.ts

@@ -0,0 +1,2 @@
+export function clsx(...args: any[]): string;
+export default clsx;

package/dist/components/external/clsx.js

@@ -0,0 +1,44 @@
+function toVal(mix) {
+    var k, y, str = "";
+    if (typeof mix === "string" || typeof mix === "number") {
+        str += mix;
+    }
+    else if (typeof mix === "object") {
+        if (Array.isArray(mix)) {
+            var len = mix.length;
+            for (k = 0; k < len; k++) {
+                if (mix[k]) {
+                    if ((y = toVal(mix[k]))) {
+                        if (str)
+                            str += " ";
+                        str += y;
+                    }
+                }
+            }
+        }
+        else {
+            for (y in mix) {
+                if (mix[y]) {
+                    if (str)
+                        str += " ";
+                    str += y;
+                }
+            }
+        }
+    }
+    return str;
+}
+export function clsx() {
+    var i = 0, tmp, x, str = "", len = arguments.length;
+    for (; i < len; i++) {
+        if ((tmp = arguments[i])) {
+            if ((x = toVal(tmp))) {
+                if (str)
+                    str += " ";
+                str += x;
+            }
+        }
+    }
+    return str;
+}
+export default clsx;

package/dist/components/external/floating-ui.d.ts

@@ -0,0 +1,268 @@
+/**
+ * Provides data to position an inner element of the floating element so that it
+ * appears centered to the reference element.
+ * @see https://floating-ui.com/docs/arrow
+ */
+export function arrow(options: any): {
+    name: string;
+    options: any;
+    fn(state: any): Promise<{
+        data?: undefined;
+        reset?: undefined;
+    } | {
+        [x: string]: any;
+        data: {
+            alignmentOffset?: number | undefined;
+            centerOffset: number;
+        };
+        reset: boolean;
+    }>;
+};
+/**
+ * Optimizes the visibility of the floating element by choosing the placement
+ * that has the most space available automatically, without needing to specify a
+ * preferred placement. Alternative to `flip`.
+ * @see https://floating-ui.com/docs/autoPlacement
+ */
+export function autoPlacement(options: any): {
+    name: string;
+    options: any;
+    fn(state: any): Promise<{
+        reset?: undefined;
+        data?: undefined;
+    } | {
+        reset: {
+            placement: any;
+        };
+        data?: undefined;
+    } | {
+        data: {
+            index: any;
+            overflows: any[];
+        };
+        reset: {
+            placement: any;
+        };
+    }>;
+};
+/**
+ * Automatically updates the position of the floating element when necessary.
+ * Should only be called when the floating element is mounted on the DOM or
+ * visible on the screen.
+ * @returns cleanup function that should be invoked when the floating element is
+ * removed from the DOM or hidden from the screen.
+ * @see https://floating-ui.com/docs/autoUpdate
+ */
+export function autoUpdate(reference: any, floating: any, update: any, options: any): () => void;
+/**
+ * Computes the `x` and `y` coordinates that will place the floating element
+ * next to a given reference element.
+ */
+export function computePosition(reference: any, floating: any, options: any): Promise<{
+    x: any;
+    y: any;
+    placement: any;
+    strategy: any;
+    middlewareData: {};
+}>;
+/**
+ * Resolves with an object of overflow side offsets that determine how much the
+ * element is overflowing a given clipping boundary on each side.
+ * - positive = overflowing the boundary by that number of pixels
+ * - negative = how many pixels left before it will overflow
+ * - 0 = lies flush with the boundary
+ * @see https://floating-ui.com/docs/detectOverflow
+ */
+export function detectOverflow(state: any, options: any): Promise<{
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+}>;
+/**
+ * Optimizes the visibility of the floating element by flipping the `placement`
+ * in order to keep it in view when the preferred placement(s) will overflow the
+ * clipping boundary. Alternative to `autoPlacement`.
+ * @see https://floating-ui.com/docs/flip
+ */
+export function flip(options: any): {
+    name: string;
+    options: any;
+    fn(state: any): Promise<{
+        data?: undefined;
+        reset?: undefined;
+    } | {
+        data: {
+            index: any;
+            overflows: any;
+        };
+        reset: {
+            placement: any;
+        };
+    } | {
+        reset: {
+            placement: any;
+        };
+        data?: undefined;
+    }>;
+};
+export function getOverflowAncestors(node: any, list: any, traverseIframes: any): any;
+/**
+ * Provides data to hide the floating element in applicable situations, such as
+ * when it is not in the same clipping context as the reference element.
+ * @see https://floating-ui.com/docs/hide
+ */
+export function hide(options: any): {
+    name: string;
+    options: any;
+    fn(state: any): Promise<{
+        data: {
+            referenceHiddenOffsets: {
+                top: number;
+                right: number;
+                bottom: number;
+                left: number;
+            };
+            referenceHidden: boolean;
+            escapedOffsets?: undefined;
+            escaped?: undefined;
+        };
+    } | {
+        data: {
+            escapedOffsets: {
+                top: number;
+                right: number;
+                bottom: number;
+                left: number;
+            };
+            escaped: boolean;
+            referenceHiddenOffsets?: undefined;
+            referenceHidden?: undefined;
+        };
+    } | {
+        data?: undefined;
+    }>;
+};
+/**
+ * Provides improved positioning for inline reference elements that can span
+ * over multiple lines, such as hyperlinks or range selections.
+ * @see https://floating-ui.com/docs/inline
+ */
+export function inline(options: any): {
+    name: string;
+    options: any;
+    fn(state: any): Promise<{
+        reset: {
+            rects: any;
+        };
+    } | {
+        reset?: undefined;
+    }>;
+};
+/**
+ * Built-in `limiter` that will stop `shift()` at a certain point.
+ */
+export function limitShift(options: any): {
+    options: any;
+    fn(state: any): {
+        [x: string]: any;
+    };
+};
+/**
+ * Modifies the placement by translating the floating element along the
+ * specified axes.
+ * A number (shorthand for `mainAxis` or distance), or an axes configuration
+ * object may be passed.
+ * @see https://floating-ui.com/docs/offset
+ */
+export function offset(options: any): {
+    name: string;
+    options: any;
+    fn(state: any): Promise<{
+        x?: undefined;
+        y?: undefined;
+        data?: undefined;
+    } | {
+        x: any;
+        y: any;
+        data: {
+            placement: any;
+            x: number;
+            y: number;
+        };
+    }>;
+};
+export namespace platform {
+    export { convertOffsetParentRelativeRectToViewportRelativeRect };
+    export { getDocumentElement };
+    export { getClippingRect };
+    export { getOffsetParent };
+    export { getElementRects };
+    export { getClientRects };
+    export { getDimensions };
+    export { getScale };
+    export { isElement };
+    export { isRTL };
+}
+/**
+ * Optimizes the visibility of the floating element by shifting it in order to
+ * keep it in view when it will overflow the clipping boundary.
+ * @see https://floating-ui.com/docs/shift
+ */
+export function shift(options: any): {
+    name: string;
+    options: any;
+    fn(state: any): Promise<any>;
+};
+/**
+ * Provides data that allows you to change the size of the floating element —
+ * for instance, prevent it from overflowing the clipping boundary or match the
+ * width of the reference element.
+ * @see https://floating-ui.com/docs/size
+ */
+export function size(options: any): {
+    name: string;
+    options: any;
+    fn(state: any): Promise<{
+        reset: {
+            rects: boolean;
+        };
+    } | {
+        reset?: undefined;
+    }>;
+};
+declare function convertOffsetParentRelativeRectToViewportRelativeRect(_ref: any): any;
+declare function getDocumentElement(node: any): any;
+declare function getClippingRect(_ref: any): {
+    width: number;
+    height: number;
+    x: any;
+    y: any;
+};
+declare function getOffsetParent(element: any, polyfill: any): any;
+declare function getElementRects(data: any): Promise<{
+    reference: {
+        x: number;
+        y: number;
+        width: any;
+        height: any;
+    };
+    floating: {
+        x: number;
+        y: number;
+        width: any;
+        height: any;
+    };
+}>;
+declare function getClientRects(element: any): any[];
+declare function getDimensions(element: any): {
+    width: number;
+    height: number;
+};
+declare function getScale(element: any): {
+    x: any;
+    y: any;
+};
+declare function isElement(value: any): boolean;
+declare function isRTL(element: any): boolean;
+export {};