@1771technologies/lytenyte-pro 2.0.0-dev.0 → 2.0.0-dev.2

package/dist/data-source-tree/use-tree-data-source.js

@@ -0,0 +1,101 @@
+import { useTree } from "./source/use-tree.js";
+import { useMemo } from "react";
+import { useRowById } from "./source/use-row-by-id.js";
+import { useControlledState } from "./source/use-controlled-state.js";
+import { useFlattened } from "./source/use-flattened.js";
+import { useEvent, useGlobalRefresh, useOnRowsSelected, usePiece, useRowByIndex, useRowIsSelected, useRows, useRowsBetween, useRowSelection, useRowSelectionState, useRowsSelected, useSortFn, } from "@1771technologies/lytenyte-core/internal";
+import { useRowParents } from "./source/use-row-parents.js";
+import { useRowLeafs } from "./source/use-row-leafs.js";
+import { useRowChildren } from "./source/use-row-children.js";
+import { useOnRowsUpdated } from "./source/use-on-rows-updated.js";
+import { useRowSiblings } from "./source/use-row-siblings.js";
+const emptyKey = [];
+export function useTreeDataSource(p) {
+    const sortFn = useSortFn(p.sort);
+    const state = useControlledState(p);
+    const tree = useTree(p);
+    const flat = useFlattened(tree, state.expandedFn, p.topData, p.botData, p.rowSelectionIdUniverseAdditions, p.rowSelectionIdUniverseSubtractions, sortFn);
+    const top$ = usePiece(flat.topCount);
+    const bot$ = usePiece(flat.botCount);
+    const rowCount$ = usePiece(flat.rowCount);
+    const maxDepth$ = usePiece(flat.maxDepth);
+    const rows$ = usePiece(flat.rows);
+    const rows = useRows(flat.rows);
+    const globalSignal = useGlobalRefresh();
+    const rowById = useRowById(tree);
+    const rowParents = useRowParents(tree);
+    const idToSpec = useEvent((id) => {
+        const node = tree.rowIdToNode.get(id);
+        if (!node)
+            return null;
+        return { size: node.children.size, children: node.children };
+    });
+    const selectionState = useRowSelection(p.rowSelection, p.onRowSelectionChange, p.rowsIsolatedSelection ?? false, p.rowSelectKey ?? emptyKey, flat.idUniverse, flat.rootIds, flat.rootCount, globalSignal);
+    const onRowsSelected = useOnRowsSelected(selectionState, idToSpec, rowParents, p.rowsIsolatedSelection ?? false, globalSignal);
+    const rowIsSelected = useRowIsSelected(selectionState, rowParents, rowById);
+    const { rowByIndex, rowInvalidate } = useRowByIndex(rows$, globalSignal, selectionState, rowParents);
+    const rowsSelected = useRowsSelected(selectionState, tree.rowIdToNode, rowParents);
+    const rowSelectionState = useRowSelectionState(selectionState);
+    const rowsBetween = useRowsBetween({ current: flat.idToIndex }, rowByIndex);
+    const rowLeafs = useRowLeafs(tree);
+    const rowChildren = useRowChildren(tree);
+    const rowSiblings = useRowSiblings(tree);
+    const rowIdToIndex = usePiece(flat.idToIndex);
+    const setExpansions = state.onExpansionsChange;
+    const onRowsUpdated = useOnRowsUpdated(tree, p);
+    const selection$ = usePiece(selectionState.rowSelectionsRaw);
+    const source = useMemo(() => {
+        const s = {
+            rowByIndex,
+            rowById,
+            rowInvalidate,
+            rowParents,
+            rowIsSelected,
+            rowsSelected,
+            rowSelectionState,
+            rowsBetween,
+            rowLeafs,
+            rowChildren,
+            rowSiblings,
+            rowIndexToRowId: (i) => s.rowByIndex(i).get()?.id ?? null,
+            rowIdToRowIndex: (id) => rowIdToIndex.get().get(id) ?? null,
+            rowUpdate: onRowsUpdated,
+            rowGroupExpansionChange: (delta) => {
+                setExpansions(delta);
+            },
+            onViewChange: () => { },
+            useBottomCount: bot$.useValue,
+            useRowCount: rowCount$.useValue,
+            useTopCount: top$.useValue,
+            useRows: rows.useValue,
+            useMaxRowGroupDepth: maxDepth$.useValue,
+            useSelectionState: selection$.useValue,
+            onRowsSelected,
+            onRowsUpdated,
+        };
+        return s;
+    }, [
+        bot$.useValue,
+        maxDepth$.useValue,
+        onRowsSelected,
+        onRowsUpdated,
+        rowById,
+        rowByIndex,
+        rowChildren,
+        rowCount$.useValue,
+        rowIdToIndex,
+        rowInvalidate,
+        rowIsSelected,
+        rowLeafs,
+        rowParents,
+        rowSelectionState,
+        rowSiblings,
+        rows.useValue,
+        rowsBetween,
+        rowsSelected,
+        selection$.useValue,
+        setExpansions,
+        top$.useValue,
+    ]);
+    return source;
+}

package/dist/data-source-tree/utils/is-object.d.ts

@@ -0,0 +1 @@
+export declare function isObject(x: any): boolean;

package/dist/data-source-tree/utils/is-object.js

@@ -0,0 +1,3 @@
+export function isObject(x) {
+    return x !== null && typeof x === "object" && !Array.isArray(x);
+}

package/dist/hooks/use-slot/get-element-ref.d.ts

@@ -0,0 +1,2 @@
+import type { ReactElement } from "react";
+export declare function getElementRef(element: ReactElement): any;

package/dist/hooks/use-slot/get-element-ref.js

@@ -0,0 +1,20 @@
+import { isReactVersionAtLeast } from "./react-version.js";
+export function getElementRef(element) {
+    // React <=18 in DEV
+    if (isReactVersionAtLeast(18)) {
+        const getter = Object.getOwnPropertyDescriptor(element.props, "ref")?.get;
+        const mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+        if (mayWarn) {
+            return element.ref;
+        }
+    }
+    if (isReactVersionAtLeast(19)) {
+        const getter = Object.getOwnPropertyDescriptor(element, "ref")?.get;
+        const mayWarn = getter && "isReactWarning" in getter && getter.isReactWarning;
+        if (mayWarn) {
+            return element.props.ref;
+        }
+    }
+    // Not DEV
+    return element.props.ref || element.ref;
+}

package/dist/hooks/use-slot/index.d.ts

@@ -0,0 +1,3 @@
+export type { UseSlotProps } from "./use-slot.js";
+export { useSlot } from "./use-slot.js";
+export type { SlotComponent } from "./types.js";

package/dist/hooks/use-slot/index.js

@@ -0,0 +1 @@
+export { useSlot } from "./use-slot.js";

package/dist/hooks/use-slot/merge-props.d.ts

@@ -0,0 +1,4 @@
+import type { AnyProps } from "./types.js";
+export declare function mergeProps(slotProps: AnyProps, childProps: AnyProps): {
+    [x: string]: any;
+};

package/dist/hooks/use-slot/merge-props.js

@@ -0,0 +1,27 @@
+export function mergeProps(slotProps, childProps) {
+    // all child props should override
+    const overrideProps = { ...childProps };
+    for (const propName in childProps) {
+        const slotPropValue = slotProps[propName];
+        const childPropValue = childProps[propName];
+        const isHandler = /^on[A-Z]/.test(propName);
+        if (isHandler) {
+            // if the handler exists on both, we compose them
+            if (slotPropValue && childPropValue) {
+                overrideProps[propName] = (...args) => {
+                    const result = childPropValue(...args);
+                    slotPropValue(...args);
+                    return result;
+                };
+            }
+        }
+        // if it's `style`, we merge them
+        else if (propName === "style") {
+            overrideProps[propName] = { ...slotPropValue, ...childPropValue };
+        }
+        else if (propName === "className") {
+            overrideProps[propName] = [slotPropValue, childPropValue].filter(Boolean).join(" ");
+        }
+    }
+    return { ...slotProps, ...overrideProps };
+}

package/dist/hooks/use-slot/react-version.d.ts

@@ -0,0 +1,3 @@
+type SupportedVersions = 17 | 18 | 19;
+export declare function isReactVersionAtLeast(reactVersionToCheck: SupportedVersions): boolean;
+export {};

package/dist/hooks/use-slot/react-version.js

@@ -0,0 +1,5 @@
+import { version } from "react";
+const majorVersion = parseInt(version, 10);
+export function isReactVersionAtLeast(reactVersionToCheck) {
+    return majorVersion >= reactVersionToCheck;
+}

package/dist/hooks/use-slot/types.d.ts

@@ -0,0 +1,4 @@
+import type { ReactElement, Ref } from "react";
+export type AnyProps = Record<string, any>;
+export type AnyRef = Ref<any>;
+export type SlotComponent<T = any> = ReactElement | ((state: T) => ReactElement);

package/dist/hooks/use-slot/types.js

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

package/dist/hooks/use-slot/use-slot.d.ts

@@ -0,0 +1,12 @@
+import { type ReactElement } from "react";
+import type { AnyProps, AnyRef } from "./types.js";
+export interface UseSlotProps {
+    readonly ref?: AnyRef;
+    readonly props?: AnyProps | AnyProps[];
+    readonly slot?: ReactElement | ((...args: any) => ReactElement);
+    readonly state?: any;
+}
+/**
+ * A React hook to support slots in components.
+ */
+export declare function useSlot({ props, slot, state, ref: forwardedRef }: UseSlotProps): ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;

package/dist/hooks/use-slot/use-slot.js

@@ -0,0 +1,28 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { cloneElement } from "react";
+import { mergeProps } from "./merge-props.js";
+import { getElementRef } from "./get-element-ref.js";
+import { useCombinedRefs } from "@1771technologies/lytenyte-core/internal";
+/**
+ * A React hook to support slots in components.
+ */
+export function useSlot({ props = {}, slot = _jsx("div", {}), state, ref: forwardedRef }) {
+    const el = typeof slot === "function" ? slot(state) : slot;
+    let merged = {};
+    if (Array.isArray(props)) {
+        for (let i = 0; i < props.length; i++)
+            merged = mergeProps(merged, props[i]);
+    }
+    else {
+        merged = props;
+    }
+    const mergedProps = mergeProps(merged, el.props);
+    const ref = getElementRef(el);
+    const mergedRefs = useCombinedRefs(forwardedRef, ref);
+    // One of the refs should be fined. We have to check for this since
+    // not all elements accept a ref (e.g. Fragments)
+    if (ref || forwardedRef) {
+        mergedProps.ref = mergedRefs;
+    }
+    return cloneElement(el, mergedProps);
+}

package/dist/hooks/use-transitioned-open.d.ts

@@ -0,0 +1,2 @@
+export type Transitioned = "idle" | "closing" | "opening";
+export declare function useTransitioned(open: boolean, el: HTMLElement | null, changeComplete?: (b: boolean) => void): [Transitioned, boolean];

package/dist/hooks/use-transitioned-open.js

@@ -0,0 +1,50 @@
+import { useEffect, useMemo, useState } from "react";
+import { onAnimationFinished } from "@1771technologies/lytenyte-shared";
+export function useTransitioned(open, el, changeComplete) {
+    const [m, setM] = useState(open);
+    const t = useMemo(() => {
+        if (open && !m)
+            return "opening";
+        if (!open && m)
+            return "closing";
+        return "idle";
+    }, [m, open]);
+    useEffect(() => {
+        if (!m || !open || !el)
+            return;
+        const controller = new AbortController();
+        onAnimationFinished({
+            element: el,
+            fn: () => {
+                changeComplete?.(true);
+            },
+            signal: controller.signal,
+        });
+        return () => controller.abort();
+    }, [changeComplete, el, m, open]);
+    useEffect(() => {
+        if ((!open && !m) || (m && open))
+            return;
+        if (open && !m) {
+            requestAnimationFrame(() => setM(open));
+            if (!el)
+                return;
+        }
+        if (!open && m) {
+            const controller = new AbortController();
+            if (!el)
+                return;
+            onAnimationFinished({
+                element: el,
+                fn: () => {
+                    setM(false);
+                    changeComplete?.(!m);
+                },
+                signal: controller.signal,
+            });
+            return () => controller.abort();
+        }
+    }, [changeComplete, el, m, open]);
+    const shouldMount = open || m;
+    return [t, shouldMount];
+}

package/dist/index.d.ts

@@ -0,0 +1,121 @@
+export { activateLicense } from "./license.js";
+import { Grid as GridCore } from "@1771technologies/lytenyte-core";
+import type { PropsWithChildren, ReactNode } from "react";
+import { Root } from "./root/root.js";
+import type { RowSource } from "@1771technologies/lytenyte-shared";
+import type * as LnTypes from "./types/index.js";
+export interface GridComponent {
+    <Spec extends Root.GridSpec = Root.GridSpec>(props: PropsWithChildren<Root.Props<Spec> & (undefined extends Spec["api"] ? unknown : {
+        apiExtension: ((incomplete: Root.API<Spec>) => Spec["api"] | null) | Spec["api"];
+    })>): ReactNode;
+    Header: typeof GridCore.Header;
+    HeaderRow: typeof GridCore.HeaderRow;
+    HeaderCell: typeof GridCore.HeaderCell;
+    HeaderGroupCell: typeof GridCore.HeaderGroupCell;
+    RowsContainer: typeof GridCore.RowsContainer;
+    RowsTop: typeof GridCore.RowsTop;
+    RowsCenter: typeof GridCore.RowsCenter;
+    RowsBottom: typeof GridCore.RowsBottom;
+    Row: typeof GridCore.Row;
+    RowFullWidth: typeof GridCore.RowFullWidth;
+    Cell: typeof GridCore.Cell;
+    Viewport: typeof GridCore.Viewport;
+}
+export declare const Grid: GridComponent;
+export declare namespace Grid {
+    type GridSpec<T = unknown, C extends Record<string, any> = object, S extends RowSource<T> = RowSource, E extends Record<string, any> = object> = Root.GridSpec<T, C, S, E>;
+    type Props<Spec extends GridSpec = GridSpec> = Root.Props<Spec>;
+    type API<Spec extends GridSpec = GridSpec> = Root.API<Spec>;
+    type Column<Spec extends GridSpec = GridSpec> = Root.Column<Spec>;
+    type ColumnBase<Spec extends GridSpec = GridSpec> = Required<Root.Props<Spec>>["columnBase"];
+    type ColumnMarker<Spec extends GridSpec = GridSpec> = Required<Root.Props<Spec>>["columnMarker"];
+    type RowGroupColumn<Spec extends GridSpec = GridSpec> = Required<Root.Props<Spec>>["rowGroupColumn"];
+    type Events<Spec extends GridSpec = GridSpec> = Required<Root.Props<Spec>>["events"];
+    type Style = LnTypes.GridStyle;
+    namespace Components {
+        type Header = GridCore.Components.Header;
+        type HeaderRow = GridCore.Components.HeaderRow;
+        type HeaderCell = GridCore.Components.HeaderCell;
+        type HeaderGroupCell = GridCore.Components.HeaderGroupCell;
+        type RowsContainer = GridCore.Components.RowsContainer;
+        type RowsTop = GridCore.Components.RowsTop;
+        type RowsCenter = GridCore.Components.RowsCenter;
+        type RowsBottom = GridCore.Components.RowsBottom;
+        type Row = GridCore.Components.Row;
+        type RowFullWidth = GridCore.Components.RowFullWidth;
+        type Cell = GridCore.Components.Cell;
+        type Viewport = GridCore.Components.Viewport;
+    }
+    namespace T {
+        type AggregationFn<T> = LnTypes.AggregationFn<T>;
+        type Aggregator<T> = LnTypes.Aggregator<T>;
+        type CellParams<Spec extends GridSpec> = LnTypes.CellParams<Spec>;
+        type CellParamsWithIndex<Spec extends GridSpec> = LnTypes.CellParamsWithIndex<Spec>;
+        type CellRendererParams<Spec extends GridSpec> = LnTypes.CellRendererParams<Spec>;
+        type DataRect = LnTypes.DataRect;
+        type Dimension<T> = LnTypes.Dimension<T>;
+        type DimensionAgg<T> = LnTypes.DimensionAgg<T>;
+        type DimensionSort<T> = LnTypes.DimensionSort<T>;
+        type EditParams<Spec extends GridSpec> = LnTypes.EditParams<Spec>;
+        type ExportDataRectResult<Spec extends GridSpec> = LnTypes.ExportDataRectResult<Spec>;
+        type Field<T> = LnTypes.Field<T>;
+        type FilterFn<T> = LnTypes.FilterFn<T>;
+        type GroupFn<T> = LnTypes.GroupFn<T>;
+        type GroupIdFn = LnTypes.GroupIdFn;
+        type HeaderGroupParams<Spec extends GridSpec> = LnTypes.HeaderGroupParams<Spec>;
+        type HeaderParams<Spec extends GridSpec> = LnTypes.HeaderParams<Spec>;
+        type LeafIdFn<T> = LnTypes.LeafIdFn<T>;
+        type PathField = LnTypes.PathField;
+        type RowParams<Spec extends GridSpec> = LnTypes.RowParams<Spec>;
+        type RowSelectionState = LnTypes.RowSelectionState;
+        type SortFn<T> = LnTypes.SortFn<T>;
+        type RowFullWidthRendererParams<Spec extends GridSpec> = LnTypes.RowFullWidthRendererParams<Spec>;
+        type RowSelectionIsolated = LnTypes.RowSelectionIsolated;
+        type RowSelectionLinked = LnTypes.RowSelectionLinked;
+        type RowSelectNode = LnTypes.RowSelectNode;
+        type RowDragPlaceholderFn = GridCore.T.RowDragPlaceholderFn;
+        type DragItem = GridCore.T.DragItem;
+        type DragItemSiteLocal = GridCore.T.DragItemSiteLocal;
+        type DragItemTransfer = GridCore.T.DragItemTransfer;
+        type RowNode<T> = LnTypes.RowNode<T>;
+        type RowLeaf<T> = LnTypes.RowLeaf<T>;
+        type RowGroup = LnTypes.RowGroup;
+        type RowAggregated = LnTypes.RowAggregated;
+        type ColumnPin = LnTypes.ColumnPin;
+        type LayoutCell = LnTypes.LayoutCell;
+        type LayoutHeader = LnTypes.LayoutHeader;
+        type LayoutHeaderCell = LnTypes.LayoutHeaderCell;
+        type LayoutHeaderGroup = LnTypes.LayoutHeaderGroup;
+        type LayoutHeaderFloating = LnTypes.LayoutHeaderFloating;
+        type LayoutFullWidthRow = LnTypes.LayoutFullWidthRow;
+        type LayoutRow = LnTypes.LayoutRow;
+        type LayoutRowWithCells = LnTypes.LayoutRowWithCells;
+        type PositionDetailCell = LnTypes.PositionDetailCell;
+        type PositionFloatingCell = LnTypes.PositionFloatingCell;
+        type PositionFullWidthRow = LnTypes.PositionFullWidthRow;
+        type PositionGridCell = LnTypes.PositionGridCell;
+        type PositionGridCellRoot = LnTypes.PositionGridCellRoot;
+        type PositionHeaderCell = LnTypes.PositionHeaderCell;
+        type PositionHeaderGroupCell = LnTypes.PositionHeaderGroupCell;
+        type PositionUnion = LnTypes.PositionUnion;
+        type DataRectSplit = LnTypes.DataRectSplit;
+        type HavingFilterFn = LnTypes.HavingFilterFn;
+        type LabelFilter = LnTypes.LabelFilter;
+        type PivotField<Spec extends GridSpec> = LnTypes.PivotField<Spec>;
+        type PivotModel<Spec extends GridSpec> = LnTypes.PivotModel<Spec>;
+        type PivotState = LnTypes.PivotState;
+        type VirtualTarget = LnTypes.VirtualTarget;
+    }
+}
+export type { UseClientDataSourceParams, RowSourceClient, } from "./data-source-client/use-client-data-source.js";
+export { useClientDataSource } from "./data-source-client/use-client-data-source.js";
+export type { UseServerDataSourceParams, RowSourceServer, } from "./data-source-server/use-server-data-source.js";
+export { useServerDataSource } from "./data-source-server/use-server-data-source.js";
+export type * from "./data-source-server/types.js";
+export type { RowSourceTree, UseTreeDataSourceParams } from "./data-source-tree/use-tree-data-source.js";
+export { useTreeDataSource } from "./data-source-tree/use-tree-data-source.js";
+export { measureText, moveRelative, equal, arrayShallow } from "@1771technologies/lytenyte-shared";
+export { getRowDragData, computeField } from "@1771technologies/lytenyte-core/internal";
+export { virtualFromXY } from "./components/virtual-from-coordinates.js";
+export type { Piece, PieceWritable } from "@1771technologies/lytenyte-core";
+export { usePiece } from "@1771technologies/lytenyte-core";

package/dist/index.js

@@ -0,0 +1,23 @@
+export { activateLicense } from "./license.js";
+import { Grid as GridCore } from "@1771technologies/lytenyte-core";
+import { Root } from "./root/root.js";
+export const Grid = Root;
+Grid.Header = GridCore.Header;
+Grid.HeaderRow = GridCore.HeaderRow;
+Grid.HeaderCell = GridCore.HeaderCell;
+Grid.HeaderGroupCell = GridCore.HeaderGroupCell;
+Grid.RowsContainer = GridCore.RowsContainer;
+Grid.RowsTop = GridCore.RowsTop;
+Grid.RowsCenter = GridCore.RowsCenter;
+Grid.RowsBottom = GridCore.RowsBottom;
+Grid.Row = GridCore.Row;
+Grid.RowFullWidth = GridCore.RowFullWidth;
+Grid.Cell = GridCore.Cell;
+Grid.Viewport = GridCore.Viewport;
+export { useClientDataSource } from "./data-source-client/use-client-data-source.js";
+export { useServerDataSource } from "./data-source-server/use-server-data-source.js";
+export { useTreeDataSource } from "./data-source-tree/use-tree-data-source.js";
+export { measureText, moveRelative, equal, arrayShallow } from "@1771technologies/lytenyte-shared";
+export { getRowDragData, computeField } from "@1771technologies/lytenyte-core/internal";
+export { virtualFromXY } from "./components/virtual-from-coordinates.js";
+export { usePiece } from "@1771technologies/lytenyte-core";

package/dist/license/index.d.ts

@@ -0,0 +1 @@
+export { activateLicense, hasAValidLicense } from "./license.js";

package/dist/license/index.js

@@ -0,0 +1 @@
+export { activateLicense, hasAValidLicense } from "./license.js";

package/dist/license/license.d.ts

@@ -0,0 +1,3 @@
+export declare let hasAValidLicense: boolean;
+export declare let licenseState: "invalid" | "expired" | null;
+export declare function activateLicense(license: string): boolean;