@1771technologies/lytenyte-pro 0.9.4 → 1.0.0-beta.0

package/dist/license.d.ts

@@ -0,0 +1,2 @@
+export function activateLicense(license: any): boolean;
+export let hasAValidLicense: boolean;

package/dist/license.js

@@ -0,0 +1,217 @@
+const hashSalt = "faec0f3c45281b1fe12d87e64a6c3271";
+const issueDate = new Date("2025-08-09");
+function getHostname() {
+    const win = globalThis?.document?.defaultView || (typeof window !== "undefined" ? window : null);
+    const loc = win?.location;
+    const { hostname = "" } = loc ?? {};
+    return hostname;
+}
+function isWebsiteUrl() {
+    const hostname = getHostname();
+    return hostname.match(/^((?:\w+\.)?1771technologies\.com)$/) !== null;
+}
+function isLocalhost() {
+    const hostname = getHostname();
+    return hostname.match(/^(?:127\.0\.0\.1|localhost)$/) !== null;
+}
+export let hasAValidLicense = isWebsiteUrl() || isLocalhost();
+export function activateLicense(license) {
+    const parts = license.split("|");
+    const details = parts[0];
+    const hash = parts[1];
+    const detailHash = new MD5().md5(details + hashSalt);
+    if (detailHash !== hash) {
+        console.error(`
+********************************************************************************
+  INVALID LICENSE KEY SUPPLIED
+
+  The license key you provided is not a valid LyteNyte Grid license key. If you
+  purchased a valid license from 1771 Technologies, please reach out to
+  our dedicated support email support@1771technologies.com.
+
+  If you are interested in purchasing a valid license, please
+  visit https://1771technolgies.com
+********************************************************************************
+`);
+        return false;
+    }
+    const detailParts = details.split(" ");
+    const endDate = new Date(detailParts[1]);
+    if (issueDate > endDate) {
+        console.error(`
+********************************************************************************
+    LICENSE EXPIRED
+
+    The license provided is a valid LyteNyte license, however it is not valid for the
+    current version of LyteNyte Grid being used. Please renew your license or use
+    the fallback version valid under your license.
+
+    To purchase a new license or learn more about which versions your license is valid
+    for please visit https://1771technologies.com.
+********************************************************************************
+`);
+        return false;
+    }
+    hasAValidLicense = true;
+    return true;
+}
+// see: https://www.myersdaily.org/joseph/javascript/md5-text.html
+// https://stackoverflow.com/a/1655795
+class MD5 {
+    md5cycle(x, k) {
+        let a = x[0];
+        let b = x[1];
+        let c = x[2];
+        let d = x[3];
+        a = this.ff(a, b, c, d, k[0], 7, -680876936);
+        d = this.ff(d, a, b, c, k[1], 12, -389564586);
+        c = this.ff(c, d, a, b, k[2], 17, 606105819);
+        b = this.ff(b, c, d, a, k[3], 22, -1044525330);
+        a = this.ff(a, b, c, d, k[4], 7, -176418897);
+        d = this.ff(d, a, b, c, k[5], 12, 1200080426);
+        c = this.ff(c, d, a, b, k[6], 17, -1473231341);
+        b = this.ff(b, c, d, a, k[7], 22, -45705983);
+        a = this.ff(a, b, c, d, k[8], 7, 1770035416);
+        d = this.ff(d, a, b, c, k[9], 12, -1958414417);
+        c = this.ff(c, d, a, b, k[10], 17, -42063);
+        b = this.ff(b, c, d, a, k[11], 22, -1990404162);
+        a = this.ff(a, b, c, d, k[12], 7, 1804603682);
+        d = this.ff(d, a, b, c, k[13], 12, -40341101);
+        c = this.ff(c, d, a, b, k[14], 17, -1502002290);
+        b = this.ff(b, c, d, a, k[15], 22, 1236535329);
+        a = this.gg(a, b, c, d, k[1], 5, -165796510);
+        d = this.gg(d, a, b, c, k[6], 9, -1069501632);
+        c = this.gg(c, d, a, b, k[11], 14, 643717713);
+        b = this.gg(b, c, d, a, k[0], 20, -373897302);
+        a = this.gg(a, b, c, d, k[5], 5, -701558691);
+        d = this.gg(d, a, b, c, k[10], 9, 38016083);
+        c = this.gg(c, d, a, b, k[15], 14, -660478335);
+        b = this.gg(b, c, d, a, k[4], 20, -405537848);
+        a = this.gg(a, b, c, d, k[9], 5, 568446438);
+        d = this.gg(d, a, b, c, k[14], 9, -1019803690);
+        c = this.gg(c, d, a, b, k[3], 14, -187363961);
+        b = this.gg(b, c, d, a, k[8], 20, 1163531501);
+        a = this.gg(a, b, c, d, k[13], 5, -1444681467);
+        d = this.gg(d, a, b, c, k[2], 9, -51403784);
+        c = this.gg(c, d, a, b, k[7], 14, 1735328473);
+        b = this.gg(b, c, d, a, k[12], 20, -1926607734);
+        a = this.hh(a, b, c, d, k[5], 4, -378558);
+        d = this.hh(d, a, b, c, k[8], 11, -2022574463);
+        c = this.hh(c, d, a, b, k[11], 16, 1839030562);
+        b = this.hh(b, c, d, a, k[14], 23, -35309556);
+        a = this.hh(a, b, c, d, k[1], 4, -1530992060);
+        d = this.hh(d, a, b, c, k[4], 11, 1272893353);
+        c = this.hh(c, d, a, b, k[7], 16, -155497632);
+        b = this.hh(b, c, d, a, k[10], 23, -1094730640);
+        a = this.hh(a, b, c, d, k[13], 4, 681279174);
+        d = this.hh(d, a, b, c, k[0], 11, -358537222);
+        c = this.hh(c, d, a, b, k[3], 16, -722521979);
+        b = this.hh(b, c, d, a, k[6], 23, 76029189);
+        a = this.hh(a, b, c, d, k[9], 4, -640364487);
+        d = this.hh(d, a, b, c, k[12], 11, -421815835);
+        c = this.hh(c, d, a, b, k[15], 16, 530742520);
+        b = this.hh(b, c, d, a, k[2], 23, -995338651);
+        a = this.ii(a, b, c, d, k[0], 6, -198630844);
+        d = this.ii(d, a, b, c, k[7], 10, 1126891415);
+        c = this.ii(c, d, a, b, k[14], 15, -1416354905);
+        b = this.ii(b, c, d, a, k[5], 21, -57434055);
+        a = this.ii(a, b, c, d, k[12], 6, 1700485571);
+        d = this.ii(d, a, b, c, k[3], 10, -1894986606);
+        c = this.ii(c, d, a, b, k[10], 15, -1051523);
+        b = this.ii(b, c, d, a, k[1], 21, -2054922799);
+        a = this.ii(a, b, c, d, k[8], 6, 1873313359);
+        d = this.ii(d, a, b, c, k[15], 10, -30611744);
+        c = this.ii(c, d, a, b, k[6], 15, -1560198380);
+        b = this.ii(b, c, d, a, k[13], 21, 1309151649);
+        a = this.ii(a, b, c, d, k[4], 6, -145523070);
+        d = this.ii(d, a, b, c, k[11], 10, -1120210379);
+        c = this.ii(c, d, a, b, k[2], 15, 718787259);
+        b = this.ii(b, c, d, a, k[9], 21, -343485551);
+        x[0] = this.add32(a, x[0]);
+        x[1] = this.add32(b, x[1]);
+        x[2] = this.add32(c, x[2]);
+        x[3] = this.add32(d, x[3]);
+    }
+    cmn(q, a, b, x, s, t) {
+        a = this.add32(this.add32(a, q), this.add32(x, t));
+        return this.add32((a << s) | (a >>> (32 - s)), b);
+    }
+    ff(a, b, c, d, x, s, t) {
+        return this.cmn((b & c) | (~b & d), a, b, x, s, t);
+    }
+    gg(a, b, c, d, x, s, t) {
+        return this.cmn((b & d) | (c & ~d), a, b, x, s, t);
+    }
+    hh(a, b, c, d, x, s, t) {
+        return this.cmn(b ^ c ^ d, a, b, x, s, t);
+    }
+    ii(a, b, c, d, x, s, t) {
+        return this.cmn(c ^ (b | ~d), a, b, x, s, t);
+    }
+    md51(s) {
+        const n = s.length;
+        const state = [1732584193, -271733879, -1732584194, 271733878];
+        let i;
+        for (i = 64; i <= s.length; i += 64) {
+            this.md5cycle(state, this.md5blk(s.substring(i - 64, i)));
+        }
+        s = s.substring(i - 64);
+        const tail = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+        for (i = 0; i < s.length; i++) {
+            tail[i >> 2] |= s.charCodeAt(i) << (i % 4 << 3);
+        }
+        tail[i >> 2] |= 0x80 << (i % 4 << 3);
+        if (i > 55) {
+            this.md5cycle(state, tail);
+            for (i = 0; i < 16; i++) {
+                tail[i] = 0;
+            }
+        }
+        tail[14] = n * 8;
+        this.md5cycle(state, tail);
+        return state;
+    }
+    /* there needs to be support for Unicode here, * unless we pretend that we can redefine the MD-5
+     * algorithm for multi-byte characters (perhaps by adding every four 16-bit characters and
+     * shortening the sum to 32 bits). Otherwise I suthis.ggest performing MD-5 as if every character
+     * was two bytes--e.g., 0040 0025 = @%--but then how will an ordinary MD-5 sum be matched?
+     * There is no way to standardize text to something like UTF-8 before transformation; speed cost is
+     * utterly prohibitive. The JavaScript standard itself needs to look at this: it should start
+     * providing access to strings as preformed UTF-8 8-bit unsigned value arrays.
+     */
+    md5blk(s) {
+        const md5blks = [];
+        for (let i = 0; i < 64; i += 4) {
+            md5blks[i >> 2] =
+                s.charCodeAt(i) +
+                    (s.charCodeAt(i + 1) << 8) +
+                    (s.charCodeAt(i + 2) << 16) +
+                    (s.charCodeAt(i + 3) << 24);
+        }
+        return md5blks;
+    }
+    rhex(n) {
+        const hex_chr = "0123456789abcdef".split("");
+        let s = "";
+        let j = 0;
+        for (; j < 4; j++) {
+            s += hex_chr[(n >> (j * 8 + 4)) & 0x0f] + hex_chr[(n >> (j * 8)) & 0x0f];
+        }
+        return s;
+    }
+    hex(x) {
+        for (let i = 0; i < x.length; i++) {
+            x[i] = this.rhex(x[i]);
+        }
+        return x.join("");
+    }
+    md5(s) {
+        return this.hex(this.md51(s));
+    }
+    add32(a, b) {
+        return this.add32Std(a, b);
+    }
+    add32Std(a, b) {
+        return (a + b) & 0xffffffff;
+    }
+}

package/dist/listbox/context.d.ts

@@ -0,0 +1,6 @@
+export interface ListboxContext {
+    readonly orientation: "horizontal" | "vertical";
+    readonly rtl: boolean;
+}
+export declare const context: import("react").Context<ListboxContext>;
+export declare const useListboxContext: () => ListboxContext;

package/dist/listbox/context.js

@@ -0,0 +1,3 @@
+import { createContext, useContext } from "react";
+export const context = createContext({ orientation: "vertical", rtl: false });
+export const useListboxContext = () => useContext(context);

package/dist/listbox/item.d.ts

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

package/dist/listbox/item.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { forwardRef } from "react";
+import { useListboxContext } from "./context";
+import { getTabbables } from "@1771technologies/lytenyte-dom-utils";
+export const Item = forwardRef(function Item(props, forwarded) {
+    const ctx = useListboxContext();
+    return (_jsx("div", { ...props, role: "option", onKeyDownCapture: (ev) => {
+            const next = ctx.rtl ? "ArrowLeft" : "ArrowRight";
+            const prev = ctx.rtl ? "ArrowRight" : "ArrowLeft";
+            if (ev.key !== next && ev.key !== prev)
+                return;
+            const items = getTabbables(ev.currentTarget);
+            if (!items.length)
+                return;
+            items.unshift(ev.currentTarget);
+            const index = items.findIndex((c) => document.activeElement === c);
+            const nextIndex = ev.key === next ? index + 1 : index - 1;
+            const itemToFocus = items[nextIndex];
+            if (!itemToFocus)
+                return;
+            ev.preventDefault();
+            ev.stopPropagation();
+            itemToFocus.focus();
+        }, ref: forwarded, tabIndex: 0, "data-ln-listbox-item": true }));
+});

package/dist/listbox/panel.d.ts

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

package/dist/listbox/panel.js

@@ -0,0 +1,50 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { forwardRef, useEffect, useState } from "react";
+import { useListboxContext } from "./context";
+import { useCombinedRefs } from "@1771technologies/lytenyte-react-hooks";
+import { getTabbables } from "@1771technologies/lytenyte-dom-utils";
+export const Panel = forwardRef(function Panel(props, forwarded) {
+    const [ref, setRef] = useState();
+    const combinedRef = useCombinedRefs(setRef, forwarded);
+    const ctx = useListboxContext();
+    useEffect(() => {
+        if (!ref)
+            return;
+        const controller = new AbortController();
+        const isVert = ctx.orientation === "vertical";
+        const nextKey = isVert ? "ArrowDown" : ctx.rtl ? "ArrowLeft" : "ArrowRight";
+        const prevKey = isVert ? "ArrowUp" : ctx.rtl ? "ArrowRight" : "ArrowLeft";
+        ref.addEventListener("keydown", (ev) => {
+            if (ev.key === "Tab") {
+                if (ref.contains(document.activeElement) || document.activeElement === ref) {
+                    ref.inert = true;
+                    setTimeout(() => {
+                        ref.inert = false;
+                    }, 10);
+                }
+            }
+            if (ev.key === nextKey) {
+                const items = getTabbables(ref).filter((c) => c.getAttribute("data-ln-listbox-item") === "true");
+                const currentIndex = items.findIndex((c) => c.contains(document.activeElement) || c === document.activeElement);
+                const focusItem = currentIndex === -1 ? items[0] : (items[currentIndex + 1] ?? items[0]);
+                if (!focusItem)
+                    return;
+                focusItem.focus();
+                ev.preventDefault();
+                ev.stopPropagation();
+            }
+            if (ev.key === prevKey) {
+                const items = getTabbables(ref).filter((c) => c.getAttribute("data-ln-listbox-item") === "true");
+                const currentIndex = items.findIndex((c) => c.contains(document.activeElement) || c === document.activeElement);
+                const focusItem = currentIndex === -1 ? items.at(-1) : (items[currentIndex - 1] ?? items.at(-1));
+                if (!focusItem)
+                    return;
+                focusItem.focus();
+                ev.preventDefault();
+                ev.stopPropagation();
+            }
+        }, { signal: controller.signal });
+        return () => controller.abort();
+    }, [ctx.orientation, ctx.rtl, ref]);
+    return (_jsxs("div", { "aria-label": "Generic listbox with keyboard navigable items", ...props, ref: combinedRef, "data-ln-listbox-panel": true, role: "listbox", tabIndex: 0, children: [props.children, _jsx("div", { "aria-label": "a presentational item that can be ignored", tabIndex: 0, onFocus: () => ref?.focus(), role: "option" })] }));
+});

package/dist/listbox/root.d.ts

@@ -0,0 +1,6 @@
+import { type PropsWithChildren } from "react";
+export interface RootProps {
+    readonly orientation?: "horizontal" | "vertical";
+    readonly rtl?: boolean;
+}
+export declare function Root(props: PropsWithChildren<RootProps>): import("react/jsx-runtime").JSX.Element;

package/dist/listbox/root.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useMemo } from "react";
+import { context } from "./context";
+export function Root(props) {
+    const value = useMemo(() => {
+        return {
+            orientation: props.orientation ?? "vertical",
+            rtl: props.rtl ?? false,
+        };
+    }, [props.orientation, props.rtl]);
+    return _jsx(context.Provider, { value: value, children: props.children });
+}

package/dist/root/dialog-driver.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useGridRoot } from "../context";
+export function DialogDriver() {
+    const grid = useGridRoot().grid;
+    const openFrameState = grid.internal.dialogFrames.useValue();
+    const frames = grid.state.dialogFrames.useValue();
+    const frameIds = Object.keys(openFrameState);
+    const openFrames = frameIds
+        .map((c) => {
+        const frame = frames[c];
+        if (!frame) {
+            console.error(`Failed to find a dialog frame with id ${c}`);
+            return null;
+        }
+        return frame;
+    })
+        .filter((c) => c);
+    return (_jsx(_Fragment, { children: openFrames.map((frame, i) => {
+            return (_jsx(frame.component, { frame: frame, grid: grid, context: openFrameState[frameIds[i]] }, frameIds[i]));
+        }) }));
+}

package/dist/root/popover-driver.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+import { useGridRoot } from "../context";
+export function PopoverDriver() {
+    const grid = useGridRoot().grid;
+    const openFrameState = grid.internal.popoverFrames.useValue();
+    const frames = grid.state.popoverFrames.useValue();
+    const frameIds = Object.keys(openFrameState);
+    const openFrames = frameIds
+        .map((c) => {
+        const frame = frames[c];
+        if (!frame) {
+            console.error(`Failed to find a dialog frame with id ${c}`);
+            return null;
+        }
+        return frame;
+    })
+        .filter((c) => c);
+    return (_jsx(_Fragment, { children: openFrames.map((frame, i) => {
+            return (_jsx(frame.component, { frame: frame, grid: grid, context: openFrameState[frameIds[i]].context, target: openFrameState[frameIds[i]].target }, frameIds[i]));
+        }) }));
+}

package/dist/root/root.d.ts

@@ -0,0 +1,8 @@
+import { type PropsWithChildren } from "react";
+import type { Grid, GridEvents } from "../+types";
+export type RootProps<T> = {
+    readonly grid: Grid<T>;
+} & {
+    [k in keyof GridEvents<T> as `on${Capitalize<k>}`]: GridEvents<T>[k];
+};
+export declare function Root<T = any>({ grid, children, ...events }: PropsWithChildren<RootProps<T>>): import("react/jsx-runtime").JSX.Element;

package/dist/root/root.js

@@ -0,0 +1,120 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useLayoutEffect, useMemo } from "react";
+import { useEvent, useMeasure } from "@1771technologies/lytenyte-react-hooks";
+import { RootProvider } from "../context";
+import { DialogDriver } from "./dialog-driver";
+import { PopoverDriver } from "./popover-driver";
+import { CellSelectionDriver } from "../cell-selection/cell-selection-driver";
+import { hasAValidLicense } from "../license";
+export function Root({ grid, children, ...events }) {
+    useEffect(() => {
+        if (hasAValidLicense)
+            return;
+        const existing = document.getElementById("lng1771-watermark");
+        if (existing)
+            return;
+        const invalidLicenseWatermark = document.createElement("div");
+        invalidLicenseWatermark.style.position = "fixed";
+        invalidLicenseWatermark.style.bottom = "0px";
+        invalidLicenseWatermark.style.insetInlineEnd = "0px";
+        invalidLicenseWatermark.style.background = "rgb(255, 167, 167)";
+        invalidLicenseWatermark.style.color = "black";
+        invalidLicenseWatermark.style.fontSize = "1.2rem";
+        invalidLicenseWatermark.style.fontWeight = "bold";
+        invalidLicenseWatermark.style.border = "1px solid black";
+        invalidLicenseWatermark.style.padding = "16px";
+        invalidLicenseWatermark.innerHTML = `LyteNyte Grid PRO is being used for evaluation. 
+      <a href="https://1771Technologies.com/pricing">Click here</a> to secure your license.`;
+        document.body.appendChild(invalidLicenseWatermark);
+        return () => invalidLicenseWatermark.remove();
+    }, []);
+    const onViewportChange = useEvent((bounds) => {
+        grid.state.viewport.set(element ?? null);
+        grid.state.viewportHeightOuter.set(bounds.height);
+        grid.state.viewportWidthOuter.set(bounds.width);
+        grid.state.viewportWidthInner.set(element?.clientWidth ?? 0);
+        grid.state.viewportHeightInner.set(element?.clientHeight ?? 0);
+    });
+    // Add event listeners in the standard react way
+    useEffect(() => {
+        const ev = Object.entries(events).map(([onName, fn]) => {
+            if (!onName.startsWith("on"))
+                return;
+            const name = onName[2].toLowerCase() + onName.slice(3);
+            return grid.api.eventAddListener(name, fn);
+        });
+        return () => ev.forEach((c) => c?.());
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [Object.values(events)]);
+    const [ref, bounds, , element] = useMeasure({
+        onChange: onViewportChange,
+    });
+    // Add css variables so that we can avoid re-renders
+    useEffect(() => {
+        return grid.state.widthTotal.watch(() => {
+            const vp = grid.state.viewport.get();
+            const width = grid.state.widthTotal.get();
+            if (!vp)
+                return;
+            vp.style.setProperty("--lng-vp-total-width", `${width}px`);
+        });
+    }, [grid]);
+    const internal = grid.internal;
+    // Listen to size changes of the window
+    useLayoutEffect(() => {
+        if (!element)
+            return;
+        const obs = new ResizeObserver(() => {
+            grid.state.viewport.set(element ?? null);
+            grid.state.viewportHeightOuter.set(bounds.height);
+            grid.state.viewportWidthOuter.set(bounds.width);
+            grid.state.viewportWidthInner.set(element?.clientWidth ?? 0);
+            grid.state.viewportHeightInner.set(element?.clientHeight ?? 0);
+        });
+        obs.observe(element);
+        const controller = new AbortController();
+        element.addEventListener("scroll", () => {
+            internal.xScroll.set(Math.abs(element.scrollLeft));
+            internal.yScroll.set(element.scrollTop);
+        }, { signal: controller.signal });
+        return () => {
+            obs.disconnect();
+            controller.abort();
+        };
+    }, [
+        bounds.height,
+        bounds.width,
+        element,
+        grid.state.viewport,
+        grid.state.viewportHeightInner,
+        grid.state.viewportHeightOuter,
+        grid.state.viewportWidthInner,
+        grid.state.viewportWidthOuter,
+        internal.xScroll,
+        internal.yScroll,
+    ]);
+    useEffect(() => {
+        return internal.focusActive.watch(() => {
+            const editActive = internal.editActivePos.get();
+            if (!editActive)
+                return;
+            const focus = internal.focusActive.get();
+            if (focus?.kind !== "cell") {
+                grid.api.editEnd();
+            }
+            else {
+                if (grid.api.editIsCellActive({ rowIndex: focus.rowIndex, column: focus.colIndex }))
+                    return;
+                grid.api.editEnd();
+            }
+        });
+    }, [grid.api, internal.editActivePos, internal.focusActive]);
+    const value = useMemo(() => {
+        return {
+            ref,
+            grid: grid,
+        };
+    }, [grid, ref]);
+    const cellSelectionMode = grid.state.cellSelectionMode.useValue();
+    return (_jsxs(RootProvider, { value: value, children: [_jsx(DialogDriver, {}), _jsx(PopoverDriver, {}), cellSelectionMode !== "none" && _jsx(CellSelectionDriver, {}), children] }));
+}

package/dist/row-data-source-client/+constants.d.ts

@@ -0,0 +1,2 @@
+export declare const LEAF = 1;
+export declare const BRANCH = 2;

package/dist/row-data-source-client/+constants.js

@@ -0,0 +1,2 @@
+export const LEAF = 1;
+export const BRANCH = 2;

package/dist/row-data-source-client/+types.d.ts

@@ -0,0 +1,27 @@
+export interface GroupItem<Data> {
+    readonly fn: (d: Data) => string | null | undefined;
+}
+export interface AggregationItem<Data> {
+    readonly fn: (d: Data[]) => unknown;
+    readonly name: string;
+}
+export interface LeafNode<Data> {
+    readonly kind: 1;
+    readonly id: string;
+    readonly data: Data;
+    readonly depth: number;
+    readonly parent: BranchNode<Data> | null;
+}
+export interface BranchNode<Data> {
+    readonly kind: 2;
+    readonly depth: number;
+    readonly id: string;
+    readonly key: string;
+    readonly children: Map<string | null, TreeNode<Data>>;
+    readonly data: Record<string, unknown>;
+    readonly parent: BranchNode<Data> | null;
+    readonly leafIds: Set<string>;
+    readonly leafData: Data[];
+}
+export type TreeNode<Data> = LeafNode<Data> | BranchNode<Data>;
+export type Root<Data> = Map<string | null, TreeNode<Data>>;

package/dist/row-data-source-client/+types.js

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

package/dist/row-data-source-client/built-ins/avg.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Calculates the average (mean) of non-null values in an array.
+ * @param data - An array of numbers that may include null values
+ * @returns The average of all non-null numbers. Returns 0 for empty arrays.
+ * @example
+ * avg([1, 2, null, 3]) // Returns 2
+ * avg([]) // Returns 0
+ * avg([null, null]) // Returns 0
+ */
+export declare function avg(data: (number | null)[]): number;

package/dist/row-data-source-client/built-ins/avg.js

@@ -0,0 +1,16 @@
+import { sum } from "./sum.js";
+/**
+ * Calculates the average (mean) of non-null values in an array.
+ * @param data - An array of numbers that may include null values
+ * @returns The average of all non-null numbers. Returns 0 for empty arrays.
+ * @example
+ * avg([1, 2, null, 3]) // Returns 2
+ * avg([]) // Returns 0
+ * avg([null, null]) // Returns 0
+ */
+export function avg(data) {
+    if (!data.length)
+        return 0;
+    const total = sum(data);
+    return total / data.length;
+}

package/dist/row-data-source-client/built-ins/built-ins.d.ts

@@ -0,0 +1,44 @@
+import { avg } from "./avg.js";
+import { count } from "./count.js";
+import { first } from "./first.js";
+import { group } from "./group.js";
+import { last } from "./last.js";
+import { max } from "./max.js";
+import { min } from "./min.js";
+import { sum } from "./sum.js";
+/**
+ * Collection of built-in array utility functions for numerical and statistical operations.
+ * Each function handles null and undefined values gracefully.
+ * @example
+ * import { builtIns } from './builtIns';
+ *
+ * const data = [1, null, 3, 2];
+ * builtIns.sum(data);  // Returns 6
+ * builtIns.avg(data);  // Returns 2
+ */
+export declare const builtIns: {
+    /** Calculate sum of non-null numbers in array */
+    sum: typeof sum;
+    /** Count non-null/undefined elements in array */
+    count: typeof count;
+    /** Calculate average of non-null numbers in array */
+    avg: typeof avg;
+    /** Get first non-null/undefined element in array */
+    first: typeof first;
+    /** Get last non-null/undefined element in array */
+    last: typeof last;
+    /** Find minimum value among non-null/undefined numbers in array */
+    min: typeof min;
+    /** Find maximum value among non-null/undefined numbers in array */
+    max: typeof max;
+    /** Return the aggregation group */
+    group: typeof group;
+};
+/**
+ * Set containing valid built-in function names.
+ * Used for validating function names and checking available operations.
+ * @example
+ * const isValidFunction = validBuiltIns.has('sum');  // Returns true
+ * const isInvalidFunction = validBuiltIns.has('median');  // Returns false
+ */
+export declare const validBuiltIns: Set<string>;