@1771technologies/lytenyte-pro 1.0.15 → 1.0.17-dev.0

package/dist/filter-selects/options.d.ts

@@ -0,0 +1,9 @@
+import type { SelectOption } from "./operator-select";
+export declare const numberOptions: SelectOption[];
+export declare const stringOptions: SelectOption[];
+export declare const dateOptions: SelectOption[];
+export declare const operatorToOption: {
+    [k: string]: SelectOption;
+};
+export declare const operatorsThatAreNumbers: Set<string>;
+export declare const filterNeedsValue: Set<string>;

package/dist/filter-selects/options.js

@@ -0,0 +1,100 @@
+export const numberOptions = [
+    { label: "Equals", value: "equals" },
+    { label: "Not Equals", value: "not_equals" },
+    { label: "Less Than", value: "less_than" },
+    { label: "Less Than Or Equals", value: "less_than_or_equals" },
+    { label: "Greater Than", value: "greater_than" },
+    { label: "Greater Than or Equals", value: "greater_than_or_equals" },
+];
+export const stringOptions = [
+    { label: "Equals", value: "equals" },
+    { label: "Not Equals", value: "not_equals" },
+    { label: "Less Than", value: "less_than" },
+    { label: "Less Than Or Equals", value: "less_than_or_equals" },
+    { label: "Greater Than", value: "greater_than" },
+    { label: "Greater Than Or Equals", value: "greater_than_or_equals" },
+    { label: "Begins With", value: "begins_with" },
+    { label: "Not Begins With", value: "not_begins_with" },
+    { label: "Ends With", value: "ends_with" },
+    { label: "Not Ends With", value: "not_ends_with" },
+    { label: "Contains", value: "contains" },
+    { label: "Not Contains", value: "not_contains" },
+    { label: "Length", value: "length" },
+    { label: "Not Length", value: "not_length" },
+    { label: "Matches", value: "matches" },
+    { label: "Length Less Than", value: "length_less_than" },
+    { label: "Length Less Than Or Equals", value: "length_less_than_or_equals" },
+    { label: "Length Greater Than", value: "length_greater_than" },
+    { label: "Length Greater Than Or Equals", value: "length_greater_than_or_equals" },
+];
+export const dateOptions = [
+    { label: "Equals", value: "equals" },
+    { label: "Not Equals", value: "not_equals" },
+    { label: "Before", value: "before" },
+    { label: "Before Or Equals", value: "before_or_equals" },
+    { label: "After", value: "after" },
+    { label: "After Or Equals", value: "after_or_equals" },
+    { label: "Year To Date", value: "year_to_date" },
+    { label: "This Week", value: "this_week" },
+    { label: "This Month", value: "this_month" },
+    { label: "This Year", value: "this_year" },
+    { label: "Last Week", value: "last_week" },
+    { label: "Last Month", value: "last_month" },
+    { label: "Last Year", value: "last_year" },
+    { label: "Next Week", value: "next_week" },
+    { label: "Next Month", value: "next_month" },
+    { label: "Next Year", value: "next_year" },
+    { label: "Today", value: "today" },
+    { label: "Tomorrow", value: "tomorrow" },
+    { label: "Yesterday", value: "yesterday" },
+    { label: "Week Of Year", value: "week_of_year" },
+    { label: "Quarter Of Year", value: "quarter_of_year" },
+    { label: "Is Weekend", value: "is_weekend" },
+    { label: "Is Weekday", value: "is_weekday" },
+    { label: "N Days Ago", value: "n_days_ago" },
+    { label: "N Days Ahead", value: "n_days_ahead" },
+    { label: "N Weeks Ago", value: "n_weeks_ago" },
+    { label: "N Weeks Ahead", value: "n_weeks_ahead" },
+    { label: "N Months Ago", value: "n_months_ago" },
+    { label: "N Months Ahead", value: "n_months_ahead" },
+    { label: "N Years Ago", value: "n_years_ago" },
+    { label: "N Years Ahead", value: "n_years_ahead" },
+];
+export const operatorToOption = Object.fromEntries([...numberOptions, ...stringOptions, ...dateOptions].map((c) => {
+    return [c.value, c];
+}));
+export const operatorsThatAreNumbers = new Set([
+    "n_days_ago",
+    "n_days_ahead",
+    "n_weeks_ago",
+    "n_weeks_ahead",
+    "n_months_ago",
+    "n_months_ahead",
+    "n_years_ago",
+    "n_years_ahead",
+    "length",
+    "not_length",
+    "length_less_than",
+    "length_less_than_or_equals",
+    "length_greater_than",
+    "length_greater_than_or_equals",
+    "week_of_year",
+    "quarter_of_year",
+]);
+export const filterNeedsValue = new Set([
+    "year_to_date",
+    "this_week",
+    "this_month",
+    "this_year",
+    "last_week",
+    "last_month",
+    "last_year",
+    "next_week",
+    "next_month",
+    "next_year",
+    "today",
+    "tomorrow",
+    "yesterday",
+    "is_weekend",
+    "is_weekday",
+]);

package/dist/filter-selects/reset.d.ts

@@ -0,0 +1,7 @@
+import { type SlotComponent } from "@1771technologies/lytenyte-core/yinternal";
+export interface ResetProps {
+    readonly as?: SlotComponent<{
+        onReset: () => void;
+    }>;
+}
+export declare const Reset: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLButtonElement> & import("react").ButtonHTMLAttributes<HTMLButtonElement> & ResetProps, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/filter-selects/reset.js

@@ -0,0 +1,22 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useSlot } from "@1771technologies/lytenyte-core/yinternal";
+import { forwardRef } from "react";
+import { useFilterSelectRoot } from "./context.js";
+function ResetImpl({ as, ...props }, ref) {
+    const ctx = useFilterSelectRoot();
+    const slot = useSlot({
+        props: [
+            {
+                onClick: ctx.reset,
+            },
+            props,
+        ],
+        ref: ref,
+        slot: as ?? _jsx("button", { children: "Reset" }),
+        state: {
+            onReset: ctx.reset,
+        },
+    });
+    return slot;
+}
+export const Reset = forwardRef(ResetImpl);

package/dist/filter-selects/root.d.ts

@@ -0,0 +1,14 @@
+import type { Dispatch, PropsWithChildren, SetStateAction } from "react";
+import type { FilterSelectFlat } from "./use-filter-select";
+export interface RootProps {
+    readonly root: {
+        readonly defaultFilter: FilterSelectFlat;
+        readonly filters: FilterSelectFlat[];
+        readonly setFilters: Dispatch<SetStateAction<FilterSelectFlat[]>>;
+        readonly apply: () => void;
+        readonly reset: () => void;
+        readonly clear: () => void;
+        readonly maxCount: number;
+    };
+}
+export declare function Root({ root, children }: PropsWithChildren<RootProps>): import("react/jsx-runtime").JSX.Element;

package/dist/filter-selects/root.js

@@ -0,0 +1,5 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { context } from "./context.js";
+export function Root({ root, children }) {
+    return _jsx(context.Provider, { value: root, children: children });
+}

package/dist/filter-selects/to-filter-item.d.ts

@@ -0,0 +1,3 @@
+import type { FilterCombination } from "../+types";
+import type { FilterSelectFlatDate, FilterSelectFlatNumber, FilterSelectFlatString } from "./use-filter-select";
+export declare function toFilterItem(f: FilterSelectFlatDate | FilterSelectFlatNumber | FilterSelectFlatString): FilterCombination["filters"][number];

package/dist/filter-selects/to-filter-item.js

@@ -0,0 +1,7 @@
+export function toFilterItem(f) {
+    if (f.kind === "number")
+        return { kind: "number", operator: f.operator, value: f.value };
+    if (f.kind === "date")
+        return { kind: "date", value: f.value, operator: f.operator };
+    return { kind: "string", value: f.value, operator: f.operator };
+}

package/dist/filter-selects/use-filter-select.d.ts

@@ -0,0 +1,38 @@
+import type { Column, FilterDateOperator, FilterNumberOperator, FilterStringOperator, Grid } from "../+types";
+export interface UseFilterSelectParams<T> {
+    readonly grid: Grid<T>;
+    readonly column: Column<T>;
+    readonly maxCount?: number;
+}
+export type FilterSelectFlatFunc = {
+    kind: "function";
+    func: any;
+};
+export type FilterSelectFlatNumber = {
+    kind: "number";
+    operator?: FilterNumberOperator;
+    value?: string | number | null;
+    nextExtender?: null | "AND" | "OR";
+};
+export type FilterSelectFlatString = {
+    kind: "string";
+    operator?: FilterStringOperator;
+    value?: string | number | null;
+    nextExtender?: null | "AND" | "OR";
+};
+export type FilterSelectFlatDate = {
+    kind: "date";
+    operator?: FilterDateOperator;
+    value?: string | number | null;
+    nextExtender?: null | "AND" | "OR";
+};
+export type FilterSelectFlat = FilterSelectFlatFunc | FilterSelectFlatNumber | FilterSelectFlatString | FilterSelectFlatDate;
+export declare const useFilterSelect: <T>({ grid, column, maxCount }: UseFilterSelectParams<T>) => {
+    reset: () => void;
+    apply: () => void;
+    clear: () => void;
+    defaultFilter: FilterSelectFlat;
+    filters: FilterSelectFlat[];
+    setFilters: (v: FilterSelectFlat[] | ((v: FilterSelectFlat[]) => FilterSelectFlat[])) => void;
+    maxCount: number;
+};

package/dist/filter-selects/use-filter-select.js

@@ -0,0 +1,168 @@
+import { useCallback, useMemo } from "react";
+import { useTwoFlowState } from "@1771technologies/lytenyte-core/yinternal";
+import { isCompleteFilter } from "./is-complete-filter.js";
+import { toFilterItem } from "./to-filter-item.js";
+export const useFilterSelect = ({ grid, column, maxCount = 2 }) => {
+    const model = grid.state.filterModel.useValue();
+    const filterOnModel = model[column.id];
+    const defaultFilter = useMemo(() => {
+        if (column.type === "date" || column.type === "datetime")
+            return { kind: "date", operator: "equals" };
+        if (column.type === "number")
+            return { kind: "number", operator: "equals" };
+        return { kind: "string", operator: "equals" };
+    }, [column.type]);
+    const filterValue = useMemo(() => {
+        if (filterOnModel) {
+            if (filterOnModel.kind === "func")
+                return [{ kind: "function", func: filterOnModel.func }];
+            if (filterOnModel.kind === "number")
+                return [{ kind: "number", value: filterOnModel.value, operator: filterOnModel.operator }];
+            if (filterOnModel.kind === "string")
+                return [{ kind: "string", value: filterOnModel.value, operator: filterOnModel.operator }];
+            if (filterOnModel.kind === "date")
+                return [{ kind: "date", value: filterOnModel.value, operator: filterOnModel.operator }];
+            if (filterOnModel.kind === "combination") {
+                const filters = [];
+                const stack = [...filterOnModel.filters.map((c) => [filterOnModel.operator, c])];
+                while (stack.length) {
+                    const [nextExtender, f] = stack.shift();
+                    if (f.kind === "combination") {
+                        stack.push(...f.filters.map((c) => [f.operator, c]));
+                    }
+                    else if (f.kind === "string") {
+                        filters.push({ kind: "string", operator: f.operator, value: f.value, nextExtender });
+                    }
+                    else if (f.kind === "number") {
+                        filters.push({ kind: "number", operator: f.operator, value: f.value, nextExtender });
+                    }
+                    else if (f.kind === "date") {
+                        filters.push({ kind: "date", operator: f.operator, value: f.value, nextExtender });
+                    }
+                }
+                return filters;
+            }
+            return [];
+        }
+        return [defaultFilter];
+    }, [filterOnModel, defaultFilter]);
+    const [filters, setFilters] = useTwoFlowState(filterValue);
+    const finalFilters = useMemo(() => {
+        if (!filters.length)
+            return [defaultFilter];
+        const last = filters.at(-1);
+        if (last.kind === "function" || filters.length >= maxCount)
+            return filters;
+        if (last.operator == undefined || last.value == null)
+            return filters;
+        return [...filters, defaultFilter];
+    }, [defaultFilter, filters, maxCount]);
+    const reset = useCallback(() => {
+        return setFilters([defaultFilter]);
+    }, [defaultFilter, setFilters]);
+    const apply = useCallback(() => {
+        const fn = finalFilters.find((c) => c.kind === "function");
+        if (fn) {
+            grid.state.filterModel.set((prev) => {
+                const next = { ...prev };
+                next[column.id] = { kind: "func", func: fn.func };
+                return prev;
+            });
+            return;
+        }
+        const filters = finalFilters.filter((c) => isCompleteFilter(c));
+        if (filters.length === 1) {
+            const filter = filters[0];
+            if (!isCompleteFilter(filter)) {
+                grid.state.filterModel.set((prev) => {
+                    const filters = { ...prev };
+                    delete filters[column.id];
+                    return filters;
+                });
+                return;
+            }
+            let next = null;
+            if (filter.kind === "date")
+                next = { kind: "date", value: filter.value, operator: filter.operator };
+            else if (filter.kind === "number")
+                next = { kind: "number", value: filter.value, operator: filter.operator };
+            else if (filter.kind === "string")
+                next = { kind: "string", value: filter.value, operator: filter.operator };
+            if (next) {
+                console.log(next);
+                grid.state.filterModel.set((prev) => {
+                    const filters = { ...prev };
+                    filters[column.id] = next;
+                    return filters;
+                });
+            }
+            return;
+        }
+        const combinedFilters = [];
+        let i = 0;
+        while (i < filters.length) {
+            const filter = filters[i];
+            if ((filter.nextExtender ?? "AND") === "AND") {
+                const ors = [filter];
+                while (i + 1 < filters.length) {
+                    const next = filters[i + 1];
+                    ors.push(next);
+                    i++;
+                    if ((next.nextExtender ?? "AND") !== "AND" || i + 1 >= filters.length)
+                        break;
+                }
+                if (ors.length > 1) {
+                    combinedFilters.push({
+                        kind: "combination",
+                        filters: ors.map(toFilterItem),
+                        operator: "AND",
+                    });
+                }
+                else {
+                    combinedFilters.push(toFilterItem(ors[0]));
+                }
+            }
+            else {
+                combinedFilters.push(toFilterItem(filter));
+            }
+            i++;
+        }
+        grid.state.filterModel.set((prev) => {
+            if (combinedFilters.length === 0) {
+                const filters = { ...prev };
+                delete filters[column.id];
+                return filters;
+            }
+            if (combinedFilters.length === 1) {
+                const filters = { ...prev };
+                filters[column.id] = combinedFilters[0];
+                return filters;
+            }
+            const filters = { ...prev };
+            filters[column.id] = { kind: "combination", filters: combinedFilters, operator: "OR" };
+            return filters;
+        });
+        return;
+    }, [column.id, finalFilters, grid.state.filterModel]);
+    const setF = useCallback((v) => {
+        const next = typeof v === "function" ? v(finalFilters) : v;
+        setFilters(next);
+    }, [finalFilters, setFilters]);
+    const clear = useCallback(() => {
+        setF([]);
+        grid.state.filterModel.set((prev) => {
+            const filters = { ...prev };
+            delete filters[column.id];
+            return filters;
+        });
+    }, [column.id, grid.state.filterModel, setF]);
+    return useMemo(() => ({
+        reset,
+        apply,
+        clear,
+        defaultFilter,
+        filters: finalFilters,
+        setFilters: setF,
+        maxCount,
+    }), [apply, clear, defaultFilter, finalFilters, maxCount, reset, setF]);
+};

package/dist/filter-selects/value-input.d.ts

@@ -0,0 +1,12 @@
+import { type SlotComponent } from "@1771technologies/lytenyte-core/yinternal";
+export interface ValueInputSlotProps {
+    readonly value: string | number | null | undefined;
+    readonly onValueChange: (v: string | number | null) => void;
+    readonly disabled: boolean;
+    readonly isNumberInput: boolean;
+    readonly filterNeedsValue: boolean;
+}
+export interface ValueInputProps {
+    readonly as?: SlotComponent<ValueInputSlotProps>;
+}
+export declare const ValueInput: import("react").ForwardRefExoticComponent<Omit<import("react").ClassAttributes<HTMLInputElement> & import("react").InputHTMLAttributes<HTMLInputElement> & ValueInputProps, "ref"> & import("react").RefAttributes<HTMLInputElement>>;

package/dist/filter-selects/value-input.js

@@ -0,0 +1,27 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useSlot } from "@1771technologies/lytenyte-core/yinternal";
+import { forwardRef } from "react";
+import { useFilterRow } from "./filter-row-context.js";
+function ValueInputImpl({ as, ...props }, ref) {
+    const ctx = useFilterRow();
+    const slot = useSlot({
+        slot: as ?? (_jsx(_Fragment, { children: !ctx.filterHasNoValue && (_jsx("input", { type: ctx.filter.kind === "number" || ctx.isNumberInput
+                    ? "number"
+                    : ctx.filter.kind === "date"
+                        ? "date"
+                        : "text", value: ctx.value ?? "", onChange: (e) => {
+                    ctx.onValueChange(e.target.value);
+                } })) })),
+        props: [props],
+        ref,
+        state: {
+            disabled: ctx.valueDisabled,
+            filterNeedsValue: ctx.filterHasNoValue,
+            isNumberInput: ctx.isNumberInput,
+            onValueChange: ctx.onValueChange,
+            value: ctx.value,
+        },
+    });
+    return slot;
+}
+export const ValueInput = forwardRef(ValueInputImpl);

package/dist/filter-tree/branch.d.ts

@@ -1,6 +1,6 @@
 import type { TreeVirtualBranch } from "../tree-view/virtualized/make-virtual-tree";
 import type { FilterInFilterItem } from "../+types";
-import { type SlotComponent } from "@1771technologies/lytenyte-react-hooks";
+import { type SlotComponent } from "@1771technologies/lytenyte-core/yinternal";
 export interface FilterTreeBranch {
     readonly item: TreeVirtualBranch<FilterInFilterItem>;
     readonly label: SlotComponent;

package/dist/filter-tree/branch.js

@@ -1,9 +1,9 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { forwardRef } from "react";
 import { TreeBranch } from "../tree-view/branch/branch.js";
-import { useSlot } from "@1771technologies/lytenyte-react-hooks";
 import { FilterTreeItemContext } from "./context.js";
 import { useTreeItem } from "./hooks/use-tree-item.js";
+import { useSlot } from "@1771technologies/lytenyte-core/yinternal";
 export const Branch = forwardRef(function Branch({ item, labelWrap, label, ...props }, forwarded) {
     const value = useTreeItem(item);
     const labelSlot = useSlot({

package/dist/filter-tree/hooks/use-filter-tree.js

@@ -1,6 +1,6 @@
 import { useEffect, useMemo, useState } from "react";
 import { useVirtualizedTree } from "../../tree-view/virtualized/use-virtualized-tree.js";
-import { useEvent } from "@1771technologies/lytenyte-react-hooks";
+import { useEvent } from "@1771technologies/lytenyte-core/yinternal";
 export function useFilterTree({ grid, column, treeItemHeight = 24, pivotMode, applyChangesImmediately = false, query, }) {
     const [items, setItems] = useState([]);
     const [expansions, onExpansionChange] = useState({});

package/dist/filter-tree/inclusion-checkbox.d.ts

@@ -1,4 +1,4 @@
-import { type SlotComponent } from "@1771technologies/lytenyte-react-hooks";
+import { type SlotComponent } from "@1771technologies/lytenyte-core/yinternal";
 export interface InclusionCheckbox {
     readonly as?: SlotComponent<{
         checked: boolean;

package/dist/filter-tree/inclusion-checkbox.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { useSlot } from "@1771technologies/lytenyte-react-hooks";
 import { forwardRef } from "react";
 import { useTreeItemContext } from "./context.js";
+import { useSlot } from "@1771technologies/lytenyte-core/yinternal";
 export const InclusionCheckbox = forwardRef(function InclusionCheckbox({ as, ...props }, forwarded) {
     const { isChecked, onCheckChange, isIndeterminate } = useTreeItemContext();
     const rendered = useSlot({

package/dist/filter-tree/label.d.ts

@@ -1,4 +1,4 @@
-import { type SlotComponent } from "@1771technologies/lytenyte-react-hooks";
+import { type SlotComponent } from "@1771technologies/lytenyte-core/yinternal";
 export interface LabelProps {
     readonly as?: SlotComponent;
 }

package/dist/filter-tree/label.js

@@ -1,7 +1,7 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { useSlot } from "@1771technologies/lytenyte-react-hooks";
 import { forwardRef, useMemo } from "react";
 import { useTreeItemContext } from "./context.js";
+import { useSlot } from "@1771technologies/lytenyte-core/yinternal";
 export const Label = forwardRef(function Label({ as, ...props }, forwarded) {
     const { item } = useTreeItemContext();
     const label = useMemo(() => {

package/dist/filter-tree/root.d.ts

@@ -1,7 +1,7 @@
 import { type PropsWithChildren } from "react";
 import type { Grid } from "../+types";
 import type { UseTreeFilterReturn } from "./hooks/use-filter-tree";
-import { type SlotComponent } from "@1771technologies/lytenyte-react-hooks";
+import { type SlotComponent } from "@1771technologies/lytenyte-core/yinternal";
 export type FilterTreeRootProps<T> = UseTreeFilterReturn<T>["rootProps"] & {
     readonly grid: Grid<T>;
     readonly loadingAs?: SlotComponent;

package/dist/filter-tree/root.js

@@ -3,7 +3,7 @@ import { useMemo } from "react";
 import { GridProvider } from "../grid-provider/provider.js";
 import { TreeRoot } from "../tree-view/root.js";
 import { FilterTreeContext } from "./context.js";
-import { useSlot } from "@1771technologies/lytenyte-react-hooks";
+import { useSlot } from "@1771technologies/lytenyte-core/yinternal";
 export function Root({ grid, treeRef, filterIn, pivotMode, columnId, children, error, loading, errorAs, loadingAs, fetchItems, items, applyChangesImmediately, filterInChange, ...rootProps }) {
     const value = useMemo(() => {
         return {

package/dist/grid/header-cell.d.ts

@@ -1,6 +1,6 @@
 import { type CSSProperties, type JSX, type ReactNode } from "react";
 import type { HeaderCellFloating, HeaderCellLayout } from "../+types";
-import { type SlotComponent } from "@1771technologies/lytenyte-react-hooks";
+import { type SlotComponent } from "@1771technologies/lytenyte-core/yinternal";
 export interface HeaderCellProps<T> {
     readonly cell: HeaderCellLayout<T> | HeaderCellFloating<T>;
     readonly resizerAs?: SlotComponent;

package/dist/grid/header-cell.js

@@ -1,4 +1,3 @@
 import {} from "react";
-import {} from "@1771technologies/lytenyte-react-hooks";
-import { HeaderCell as HeaderCellCore } from "@1771technologies/lytenyte-core/yinternal";
+import { HeaderCell as HeaderCellCore, } from "@1771technologies/lytenyte-core/yinternal";
 export const HeaderCell = HeaderCellCore;

package/dist/grid/header.d.ts

@@ -1 +1 @@
-export declare const Header: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export declare const Header: import("react").NamedExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/grid/row-full-width.d.ts

@@ -1,6 +1,6 @@
 import { type JSX, type ReactNode } from "react";
 import type { RowFullWidthRowLayout } from "../+types";
-import { type DropWrapProps } from "@1771technologies/lytenyte-shared";
+import { type DropWrapProps } from "@1771technologies/lytenyte-core/yinternal";
 export interface RowFullWidthProps extends Omit<DropWrapProps, "accepted"> {
     readonly row: RowFullWidthRowLayout<any>;
     readonly space?: "viewport" | "scroll-width";

package/dist/grid/row-full-width.js

@@ -1,4 +1,3 @@
 import {} from "react";
-import {} from "@1771technologies/lytenyte-shared";
-import { RowFullWidth as RowFullWidthCore } from "@1771technologies/lytenyte-core/yinternal";
+import { RowFullWidth as RowFullWidthCore, } from "@1771technologies/lytenyte-core/yinternal";
 export const RowFullWidth = RowFullWidthCore;

package/dist/grid/row.d.ts

@@ -1,6 +1,6 @@
 import { type JSX, type ReactNode } from "react";
 import type { RowNormalRowLayout } from "../+types";
-import { type DropWrapProps } from "@1771technologies/lytenyte-shared";
+import { type DropWrapProps } from "@1771technologies/lytenyte-core/yinternal";
 export interface RowProps extends Omit<DropWrapProps, "accepted"> {
     readonly row: RowNormalRowLayout<any>;
     readonly accepted?: string[];

package/dist/grid/row.js

@@ -1,4 +1,3 @@
 import {} from "react";
-import {} from "@1771technologies/lytenyte-shared";
 import { Row as RowCore } from "@1771technologies/lytenyte-core/yinternal";
 export const Row = RowCore;

package/dist/grid/rows-container.d.ts

@@ -1 +1 @@
-export declare const RowsContainer: import("react").ForwardRefExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;
+export declare const RowsContainer: import("react").NamedExoticComponent<Omit<import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & import("react").RefAttributes<HTMLDivElement>>;

package/dist/grid-box/item.d.ts

@@ -1,6 +1,6 @@
 import { type CSSProperties } from "react";
 import type { GridBoxItem } from "./+types";
-import { type SlotComponent } from "@1771technologies/lytenyte-react-hooks";
+import { type SlotComponent } from "@1771technologies/lytenyte-core/yinternal";
 export interface GridBoxItemProps {
     readonly item: GridBoxItem;
     readonly itemAs?: SlotComponent;

package/dist/grid-box/item.js

@@ -1,9 +1,8 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { forwardRef } from "react";
 import { Item } from "../listbox/item.js";
-import { dragState, DropWrap, useDraggable } from "@1771technologies/lytenyte-dragon";
-import { useCombinedRefs, useSlot, } from "@1771technologies/lytenyte-react-hooks";
 import { useGridBoxContext } from "./context.js";
+import { dragState, DropWrap, useCombinedRefs, useDraggable, useSlot, } from "@1771technologies/lytenyte-core/yinternal";
 export const BoxItem = forwardRef(function BoxItem({ item, itemAs, itemClassName, itemStyle, children, ...props }, forwarded) {
     const { accepted } = useGridBoxContext();
     const { dragProps } = useDraggable({

package/dist/grid-box/panel.js

@@ -1,8 +1,8 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { forwardRef } from "react";
 import { Panel } from "../listbox/panel.js";
-import { DropWrap } from "@1771technologies/lytenyte-dragon";
 import { useGridBoxContext } from "./context.js";
+import { DropWrap } from "@1771technologies/lytenyte-core/yinternal";
 export const GridBoxPanel = forwardRef(function GridBoxPanel(props, forwarded) {
     const ctx = useGridBoxContext();
     return (_jsx(DropWrap, { ...props, accepted: ctx.accepted, "data-ln-orientation": ctx.orientation, onDrop: ctx.onRootDrop, ref: forwarded, as: _jsx(Panel, {}) }));

package/dist/grid-box/use-aggregation-box-items.js

@@ -1,5 +1,5 @@
 import { useMemo } from "react";
-import { useEvent } from "@1771technologies/lytenyte-react-hooks";
+import { useEvent } from "@1771technologies/lytenyte-core/yinternal";
 export function useAggregationBoxItems({ grid, orientation }) {
     const model = grid.state.aggModel.useValue();
     const gridId = grid.state.gridId.useValue();

package/dist/grid-box/use-column-box-items.js

@@ -1,5 +1,5 @@
 import { useMemo } from "react";
-import { useEvent } from "@1771technologies/lytenyte-react-hooks";
+import { useEvent } from "@1771technologies/lytenyte-core/yinternal";
 export function useColumnBoxItems({ grid, onRootDrop, onDrop, onDelete, onAction, orientation, draggable = true, itemFilter, placeholder, }) {
     const columns = grid.state.columns.useValue();
     const base = grid.state.columnBase.useValue();

package/dist/grid-box/use-row-group-box-items.js

@@ -1,5 +1,5 @@
 import { useMemo } from "react";
-import { useEvent } from "@1771technologies/lytenyte-react-hooks";
+import { useEvent } from "@1771technologies/lytenyte-core/yinternal";
 export function useRowGroupBoxItems({ grid, orientation, hideColumnOnGroup = true, includeGroupables = false, placeholder, }) {
     const rowGroupModel = grid.state.rowGroupModel.useValue();
     const gridId = grid.state.gridId.useValue();