@vuu-ui/vuu-utils 2.1.19-beta.1 → 2.1.19-beta.2

package/src/index.js

@@ -0,0 +1,77 @@
+export * from "./array-utils.js";
+export * from "./box-utils.js";
+export * from "./broadcast-channel.js";
+export * from "./column-utils.js";
+export * from "./common-types.js";
+export * from "./component-registry.js";
+export * from "./cookie-utils.js";
+export * from "./css-utils.js";
+export * from "./data-utils.js";
+export * from "./datasource/BaseDataSource.js";
+export * from "./datasource/datasource-action-utils.js";
+export * from "./datasource/datasource-filter-utils.js";
+export * from "./datasource/datasource-utils.js";
+export * from "./date/index.js";
+export * from "./debug-utils.js";
+export * from "./event-emitter.js";
+export * from "./feature-utils.js";
+export * from "./filters/index.js";
+export * from "./form-utils.js";
+export * from "./formatting-utils.js";
+export * from "./getUniqueId.js";
+export * from "./group-utils.js";
+export * from "./html-utils.js";
+export * from "./input-utils.js";
+export * from "./invariant.js";
+export * from "./itemToString.js";
+export * from "./json-types.js";
+export * from "./json-utils.js";
+export * from "./keyboard-utils.js";
+export * from "./keyset.js";
+export * from "./layout-types.js";
+export * from "./list-utils.js";
+export * from "./local-storage-utils.js";
+export * from "./logging-utils.js";
+export * from "./module-utils.js";
+export * from "./nanoid/index.js";
+export * from "./perf-utils.js";
+export * from "./promise-utils.js";
+export * from "./protocol-message-utils.js";
+export * from "./range-utils.js";
+export * from "./react-utils.js";
+export * from "./round-decimal.js";
+export * from "./row-utils.js";
+export * from "./ScaledDecimal.js";
+export * from "./selection-utils.js";
+export * from "./shell-layout-types.js";
+export * from "./sort-utils.js";
+export * from "./table-schema-utils.js";
+export * from "./text-utils.js";
+export * from "./ThemeProvider.js";
+export * from "./tree-types.js";
+export * from "./tree-utils.js";
+export * from "./ts-utils.js";
+export * from "./typeahead-utils.js";
+export * from "./url-utils.js";
+export * from "./useId.js";
+export * from "./useLayoutEffectSkipFirst.js";
+export * from "./user-types.js";
+export * from "./useStateRef.js";
+export * from "./context-definitions/DataProvider.js";
+export * from "./context-definitions/WorkspaceContext.js";
+export * from "./ShellContext.js";
+export { RestrictToHorizontalAxis } from "@dnd-kit/abstract/modifiers";
+export { KeyboardSensor, PointerSensor } from "@dnd-kit/dom";
+export { DragDropProvider, DragOverlay, useInstance } from "@dnd-kit/react";
+export { useSortable } from "@dnd-kit/react/sortable";
+export { Clock } from "./Clock.js";
+export { DataEditingProvider, useEditSession } from "./data-editing/DataEditingProvider.js";
+export { getVuuEditMessage, isInlineEditingSession } from "./data-editing/edit-utils.js";
+export { EditButtons } from "./data-editing/EditButtons.js";
+export { EditSession, StaleUpdateError } from "./data-editing/EditSession.js";
+export { useEditableTable } from "./data-editing/useEditableTable.js";
+export { WidthHeight, WidthOnly, useResizeObserver } from "./useResizeObserver.js";
+export { DataContext } from "./context-definitions/DataContext.js";
+export { DataSourceProvider, useDataSource } from "./context-definitions/DataSourceProvider.js";
+export { PageVisibilityObserver } from "./PageVisibilityObserver.js";
+export { ThemeLoadChecker } from "./theme-utils.js";

package/src/input-utils.js

@@ -0,0 +1,3 @@
+const isCharacterKey = (key)=>1 === key.length;
+const isQuoteKey = (evt)=>'"' === evt.key || "'" === evt.key;
+export { isCharacterKey, isQuoteKey };

package/src/invariant.js

@@ -0,0 +1,9 @@
+function invariant(condition, message) {
+    if (!condition) {
+        const error = new Error(message);
+        error.name = "Invariant Violation";
+        error.framesToPop = 1;
+        throw error;
+    }
+}
+export { invariant };

package/src/itemToString.js

@@ -0,0 +1,9 @@
+const isPlainObject = (obj)=>"[object Object]" === Object.prototype.toString.call(obj);
+function itemToString(item) {
+    if ("string" == typeof item) return item;
+    if (!isPlainObject(item)) return String(item);
+    if (Object.prototype.hasOwnProperty.call(item, "label")) return String(item.label);
+    console.warn("itemToString: you've likely forgotten to set the label prop on the item object.\nYou can also provide your own `itemToString` implementation.");
+    return "";
+}
+export { itemToString };

package/src/json-utils.js

@@ -0,0 +1,108 @@
+import { metadataKeys } from "./column-utils.js";
+const { COUNT: COUNT } = metadataKeys;
+const isJsonData = (value)=>"object" == typeof value && null !== value;
+const vuuRowDataItemTypes = [
+    "boolean",
+    "number",
+    "string"
+];
+const isVuuRowDataItem = (value)=>vuuRowDataItemTypes.includes(typeof value);
+const getCellValue = (attribute, attributeValue)=>{
+    if (Array.isArray(attributeValue)) return {
+        attribute: `${attribute}[`,
+        attributeValue: "",
+        isLeaf: false
+    };
+    if (isJsonData(attributeValue)) return {
+        attribute: `${attribute}{`,
+        attributeValue: "",
+        isLeaf: false
+    };
+    if (void 0 === attributeValue) return {
+        attribute,
+        attributeValue: "undefined",
+        isLeaf: true
+    };
+    if (isVuuRowDataItem(attributeValue)) return {
+        attribute,
+        attributeValue,
+        isLeaf: true
+    };
+    throw Error(`unsupported type ${typeof attributeValue} in JSON`);
+};
+const jsonColumnType = {
+    name: "json",
+    renderer: {
+        name: "json"
+    }
+};
+const jsonToDataSourceRows = (json)=>{
+    const cols = [];
+    cols.push({
+        className: "vuuJsonCell",
+        name: "Level 1",
+        type: jsonColumnType
+    }, {
+        className: "vuuJsonCell",
+        name: "Level 2",
+        type: jsonColumnType
+    });
+    const rows = [];
+    addChildValues(rows, json, cols);
+    return [
+        cols,
+        rows
+    ];
+};
+const addChildValues = (rows, json, cols, index = {
+    value: 0
+}, keyBase = "$root", depth = 0)=>{
+    let leafCount = 0;
+    let rowCount = 0;
+    if (depth === cols.length - 1) cols.push({
+        className: "vuuJsonCell",
+        name: `Level ${cols.length + 1}`,
+        hidden: true,
+        type: jsonColumnType
+    });
+    const columnEntries = Object.entries(json);
+    for(let i = 0; i < columnEntries.length; i++, index.value += 1){
+        const [key, value] = columnEntries[i];
+        const { attribute, attributeValue, isLeaf } = getCellValue(key, value);
+        const blanks = Array(depth).fill("");
+        const fullKey = `${keyBase}|${key}`;
+        const ts = 0;
+        const isNew = false;
+        const row = [
+            index.value,
+            index.value,
+            isLeaf,
+            false,
+            depth,
+            0,
+            fullKey,
+            0,
+            ts,
+            isNew,
+            ...blanks,
+            attribute,
+            attributeValue
+        ];
+        rows.push(row);
+        rowCount += 1;
+        if (isJsonData(value)) {
+            const [nestedLeafCount, nestedRowCount] = addChildValues(rows, value, cols, {
+                value: index.value + 1
+            }, fullKey, depth + 1);
+            row[COUNT] = nestedLeafCount;
+            leafCount += nestedLeafCount;
+            rowCount += nestedRowCount;
+            index.value += nestedRowCount;
+        } else leafCount += 1;
+    }
+    return [
+        leafCount,
+        rowCount
+    ];
+};
+export { jsonToDataSourceRows };

package/src/keyboard-utils.js

@@ -0,0 +1,14 @@
+const ArrowUp = "ArrowUp";
+const ArrowDown = "ArrowDown";
+const ArrowLeft = "ArrowLeft";
+const ArrowRight = "ArrowRight";
+const Enter = "Enter";
+const Escape = "Escape";
+const Home = "Home";
+const End = "End";
+const PageUp = "PageUp";
+const PageDown = "PageDown";
+const Space = " ";
+const Tab = "Tab";
+const isArrowKey = (key)=>"ArrowUp" === key || "ArrowDown" === key || "ArrowLeft" === key || "ArrowRight" === key;
+export { ArrowDown, ArrowLeft, ArrowRight, ArrowUp, End, Enter, Escape, Home, PageDown, PageUp, Space, Tab, isArrowKey };

package/src/keyset.js

@@ -0,0 +1,57 @@
+const EMPTY = [];
+class KeySet {
+    keys = new Map();
+    nextKeyValue = 0;
+    range;
+    constructor(range){
+        this.range = range;
+        this.init(range);
+    }
+    next(free = EMPTY) {
+        if (free.length > 0) return free.shift();
+        return this.nextKeyValue++;
+    }
+    init({ from, to }) {
+        this.keys.clear();
+        this.nextKeyValue = 0;
+        for(let rowIndex = from; rowIndex < to; rowIndex++){
+            const nextKeyValue = this.next();
+            this.keys.set(rowIndex, nextKeyValue);
+        }
+        return true;
+    }
+    reset(range) {
+        const { from, to } = range;
+        const newSize = to - from;
+        const currentSize = this.range.to - this.range.from;
+        this.range = range;
+        if (currentSize > newSize) return this.init(range);
+        const freeKeys = [];
+        this.keys.forEach((keyValue, rowIndex)=>{
+            if (rowIndex < from || rowIndex >= to) {
+                freeKeys.push(keyValue);
+                this.keys.delete(rowIndex);
+            }
+        });
+        for(let rowIndex = from; rowIndex < to; rowIndex++)if (!this.keys.has(rowIndex)) {
+            const nextKeyValue = this.next(freeKeys);
+            this.keys.set(rowIndex, nextKeyValue);
+        }
+        return false;
+    }
+    keyFor(rowIndex) {
+        const key = this.keys.get(rowIndex);
+        if (void 0 === key) {
+            console.log(`key not found
+        keys: ${this.toDebugString()}
+      `);
+            throw Error(`KeySet, no key found for rowIndex ${rowIndex}`);
+        }
+        return key;
+    }
+    toDebugString() {
+        return `${this.keys.size} keys
+${Array.from(this.keys.entries()).sort(([key1], [key2])=>key1 - key2).map(([k, v])=>`${k}=>${v}`).join(",")}]\n`;
+    }
+}
+export { KeySet };

package/src/list-utils.js

@@ -0,0 +1,5 @@
+const getSelectedOption = (values, selectedValue)=>{
+    if (void 0 === selectedValue) return;
+    return values.find((option)=>option.value === selectedValue);
+};
+export { getSelectedOption };

package/src/local-storage-utils.js

@@ -0,0 +1,23 @@
+const getLocalEntity = (key, deleteOnRead = false)=>{
+    const data = localStorage.getItem(key);
+    if (data) {
+        if (deleteOnRead) localStorage.removeItem(key);
+        return JSON.parse(data);
+    }
+};
+const clearLocalEntity = (key)=>{
+    const doomedItem = localStorage.getItem(key);
+    if (!doomedItem) return false;
+    localStorage.removeItem(key);
+    return true;
+};
+const getAllLocalEntity = (url)=>Object.entries(localStorage).filter(([key])=>key.includes(url)).map(([, value])=>JSON.parse(value));
+const saveLocalEntity = (key, data)=>{
+    try {
+        localStorage.setItem(key, JSON.stringify(data));
+        return data;
+    } catch  {
+        return;
+    }
+};
+export { clearLocalEntity, getAllLocalEntity, getLocalEntity, saveLocalEntity };

package/src/logging-utils.js

@@ -0,0 +1,52 @@
+import { getCookieValue } from "./cookie-utils.js";
+const logLevels = [
+    "error",
+    "warn",
+    "info",
+    "debug"
+];
+const isValidLogLevel = (value)=>"string" == typeof value && logLevels.includes(value);
+const DEFAULT_LOG_LEVEL = "error";
+const NO_OP = ()=>void 0;
+const DEFAULT_DEBUG_LEVEL = "production" === process.env.NODE_ENV ? "error" : "info";
+const { loggingLevel: loggingLevel = DEFAULT_DEBUG_LEVEL } = getLoggingSettings();
+const logger = (category)=>{
+    const debugEnabled = "debug" === loggingLevel;
+    const infoEnabled = debugEnabled || "info" === loggingLevel;
+    const warnEnabled = infoEnabled || "warn" === loggingLevel;
+    const errorEnabled = warnEnabled || "error" === loggingLevel;
+    const info = infoEnabled ? (message)=>console.info(`${Date.now()} [${category}] ${message}`) : NO_OP;
+    const warn = warnEnabled ? (message)=>console.warn(`[${category}] ${message}`) : NO_OP;
+    const debug = debugEnabled ? (message)=>console.debug(`${Date.now()} [${category}] ${message}`) : NO_OP;
+    const error = errorEnabled ? (message)=>console.error(`[${category}] ${message}`) : NO_OP;
+    if ("production" === process.env.NODE_ENV) return {
+        errorEnabled,
+        error
+    };
+    return {
+        debugEnabled,
+        infoEnabled,
+        warnEnabled,
+        errorEnabled,
+        info,
+        warn,
+        debug,
+        error
+    };
+};
+function getLoggingSettings() {
+    if ("u" > typeof loggingSettings) return loggingSettings;
+    return {
+        loggingLevel: getLoggingLevelFromCookie()
+    };
+}
+function getLoggingLevelFromCookie() {
+    const value = getCookieValue("vuu-logging-level");
+    if (isValidLogLevel(value)) return value;
+    return DEFAULT_LOG_LEVEL;
+}
+const getLoggingConfigForWorker = ()=>`const loggingSettings = { loggingLevel: "${getLoggingLevelFromCookie()}"};`;
+const logUnhandledMessage = (message, context = "[logUnhandledStruct]")=>{
+    console.log(`${context}  ${JSON.stringify(message)}`);
+};
+export { getLoggingConfigForWorker, logUnhandledMessage, logger };

package/src/module-utils.js

@@ -0,0 +1,2 @@
+const isModule = (entity)=>void 0 !== entity && "function" != typeof entity;
+export { isModule };

package/src/nanoid/index.js

@@ -0,0 +1,13 @@
+const uuid = (size = 21)=>{
+    let id = '';
+    const bytes = crypto.getRandomValues(new Uint8Array(size));
+    while(size--){
+        const byte = 63 & bytes[size];
+        if (byte < 36) id += byte.toString(36);
+        else if (byte < 62) id += (byte - 26).toString(36).toUpperCase();
+        else if (byte < 63) id += '_';
+        else id += '-';
+    }
+    return id;
+};
+export { uuid };

package/src/perf-utils.js

@@ -0,0 +1,28 @@
+function debounce(callback, timeInterval) {
+    let timeout;
+    return (...args)=>{
+        clearTimeout(timeout);
+        timeout = window.setTimeout(()=>callback(...args), timeInterval);
+    };
+}
+function throttle(callback, limit) {
+    let wait = false;
+    let lastArgs;
+    function checkLastArgs() {
+        if (void 0 == lastArgs) wait = false;
+        else {
+            callback(...lastArgs);
+            lastArgs = void 0;
+            setTimeout(checkLastArgs, limit);
+        }
+    }
+    return (...args)=>{
+        if (wait) lastArgs = args;
+        else {
+            callback(...args);
+            wait = true;
+            setTimeout(checkLastArgs, limit);
+        }
+    };
+}
+export { debounce, throttle };

package/src/promise-utils.js

@@ -0,0 +1,26 @@
+class DeferredPromise {
+    #promise;
+    #resolve = ()=>console.log("resolve was not set");
+    #reject = ()=>console.log("reject was not set");
+    #resolved = false;
+    constructor(){
+        this.#promise = new Promise((resolve, reject)=>{
+            this.#resolve = resolve;
+            this.#reject = reject;
+        });
+    }
+    get promise() {
+        return this.#promise;
+    }
+    get isResolved() {
+        return this.#resolved;
+    }
+    resolve(value) {
+        this.#resolved = true;
+        return this.#resolve(value);
+    }
+    get reject() {
+        return this.#reject;
+    }
+}
+export { DeferredPromise };

package/src/protocol-message-utils.js

@@ -0,0 +1,68 @@
+import { isView } from "./component-registry.js";
+const MENU_RPC_TYPES = [
+    "VIEW_PORT_MENUS_SELECT_RPC",
+    "VIEW_PORT_MENU_TABLE_RPC",
+    "VIEW_PORT_MENU_ROW_RPC",
+    "VIEW_PORT_MENU_CELL_RPC"
+];
+const INVALID_SESSION = "Invalid session";
+const SESSION_LIMIT_EXCEEDED = "User session limit exceeded";
+const INVALID_TOKEN = "Invalid token";
+const TOKEN_EXPIRED = "Token has expired";
+const InvalidLoginMessages = [
+    INVALID_SESSION,
+    SESSION_LIMIT_EXCEEDED,
+    INVALID_TOKEN,
+    TOKEN_EXPIRED
+];
+const isErrorMessage = (message)=>"object" == typeof message && message?.type === "ERROR";
+const isLoginErrorMessage = (message)=>"string" == typeof message && InvalidLoginMessages.includes(message);
+const isSelectRequest = (message)=>message && "object" == typeof message && "type" in message && ("SELECT_ROW" === message.type || "DESELECT_ROW" === message.type || "SELECT_ROW_RANGE" === message.type || "SELECT_ALL" === message.type || "DESELECT_ALL" === message.type);
+const isSelectSuccessWithRowCount = (response)=>[
+        "SELECT_ROW_SUCCESS",
+        "DESELECT_ROW_SUCCESS",
+        "SELECT_ROW_RANGE_SUCCESS",
+        "SELECT_ALL_SUCCESS",
+        "DESELECT_ALL_SUCCESS"
+    ].includes(response.type ?? "") && "number" == typeof response.selectedRowCount;
+const isRpcServiceRequest = (message)=>"RPC_REQUEST" === message.type;
+const hasViewPortContext = (message)=>"VIEWPORT_CONTEXT" === message.context.type;
+const isVuuMenuRpcRequest = (message)=>MENU_RPC_TYPES.includes(message["type"]);
+const isLoginResponse = (message)=>null !== message && "object" == typeof message && "type" in message && ("LOGIN_SUCCESS" === message.type || "LOGIN_FAIL" === message.type);
+const isRpcSuccess = (rpcResult)=>rpcResult?.type === "SUCCESS_RESULT";
+const isRpcError = (rpcResult)=>rpcResult?.type === "ERROR_RESULT";
+const isRequestResponse = (message)=>"requestId" in message;
+const isOpenSessionTableDialogMessage = (rpcResponse)=>"VIEW_PORT_MENU_RESP" === rpcResponse.type && isOpenDialogAction(rpcResponse.action) && "tableSchema" in rpcResponse.action;
+const isOpenDialogAction = (action)=>void 0 !== action && "OPEN_DIALOG_ACTION" === action.type;
+const isTypeaheadRequest = (request)=>isRpcServiceRequest(request) && ("getUniqueFieldValues" === request.rpcName || "getUniqueFieldValuesStartingWith" === request.rpcName);
+const isCreateVpSuccess = (response)=>"CREATE_VP_SUCCESS" === response.type;
+const isSessionTable = (table)=>{
+    if (null !== table && "object" == typeof table && "table" in table && "module" in table) return table.table.startsWith("session");
+    return false;
+};
+function isActionMessage(rpcResponse) {
+    return "VIEW_PORT_MENU_RESP" === rpcResponse.type;
+}
+function isSessionTableActionMessage(rpcResponse) {
+    return isActionMessage(rpcResponse) && isOpenDialogAction(rpcResponse.action) && isSessionTable(rpcResponse.action.table) && (rpcResponse.action?.renderComponent === "inline-form" || rpcResponse.action?.renderComponent === "grid");
+}
+function isCustomComponentActionMessage(rpcResponse) {
+    return isActionMessage(rpcResponse) && isOpenDialogAction(rpcResponse.action) && isSessionTable(rpcResponse.action.table) && "string" == typeof rpcResponse.action.renderComponent && isView(rpcResponse.action.renderComponent);
+}
+const numericTypes = [
+    "int",
+    "long",
+    "double",
+    "scaleddecimal2",
+    "scaleddecimal4",
+    "scaleddecimal6",
+    "scaleddecimal8"
+];
+function isNumericType(dataType) {
+    return numericTypes.includes(dataType);
+}
+const isAddRowRpcRequest = (rpcRequest)=>"addRow" === rpcRequest.rpcName;
+const isEditCellRpcRequest = (rpcRequest)=>"editCell" === rpcRequest.rpcName;
+const isBeginEditSessionRpcRequest = (rpcRequest)=>"beginEditSession" === rpcRequest.rpcName;
+const isEndEditSessionRpcRequest = (rpcRequest)=>"endEditSession" === rpcRequest.rpcName;
+export { INVALID_SESSION, INVALID_TOKEN, SESSION_LIMIT_EXCEEDED, TOKEN_EXPIRED, hasViewPortContext, isActionMessage, isAddRowRpcRequest, isBeginEditSessionRpcRequest, isCreateVpSuccess, isCustomComponentActionMessage, isEditCellRpcRequest, isEndEditSessionRpcRequest, isErrorMessage, isLoginErrorMessage, isLoginResponse, isNumericType, isOpenDialogAction, isOpenSessionTableDialogMessage, isRequestResponse, isRpcError, isRpcServiceRequest, isRpcSuccess, isSelectRequest, isSelectSuccessWithRowCount, isSessionTable, isSessionTableActionMessage, isTypeaheadRequest, isVuuMenuRpcRequest };

package/src/range-utils.js

@@ -0,0 +1,109 @@
+class RangeImpl {
+    from;
+    to;
+    #baseFrom;
+    #renderBufferSize = 0;
+    #baseTo;
+    constructor(from, to, renderBufferSize = 0){
+        this.from = from;
+        this.to = to;
+        this.#baseFrom = from;
+        this.#baseTo = to;
+        this.#renderBufferSize = renderBufferSize;
+    }
+    get reset() {
+        return new RangeImpl(0, this.#baseTo - this.#baseFrom, this.#renderBufferSize);
+    }
+    get withBuffer() {
+        return getFullRange(this, this.#renderBufferSize);
+    }
+    equals(range) {
+        return range.from === this.#baseFrom && range.to === this.#baseTo;
+    }
+    toJson() {
+        return {
+            from: this.from,
+            to: this.to,
+            baseFrom: this.#baseFrom,
+            baseTo: this.#baseTo,
+            renderBufferSize: this.#renderBufferSize
+        };
+    }
+}
+const Range = (from, to, renderBufferSize)=>new RangeImpl(from, to, renderBufferSize);
+const NULL_RANGE = Range(0, 0);
+function getFullRange({ from, to }, bufferSize = 0, totalRowCount = Number.MAX_SAFE_INTEGER) {
+    if (0 === from && 0 === to) return {
+        from,
+        to
+    };
+    if (0 === bufferSize) if (totalRowCount < from) return {
+        from: 0,
+        to: 0
+    };
+    else return {
+        from,
+        to: Math.min(to, totalRowCount)
+    };
+    {
+        if (0 === from) return {
+            from,
+            to: Math.min(to + bufferSize, totalRowCount)
+        };
+        const shortfallBefore = from - bufferSize < 0;
+        const shortfallAfter = totalRowCount - (to + bufferSize) < 0;
+        if (shortfallBefore && shortfallAfter) return {
+            from: 0,
+            to: totalRowCount
+        };
+        if (shortfallBefore) return {
+            from: 0,
+            to: to + bufferSize
+        };
+        if (shortfallAfter) return {
+            from: Math.max(0, from - bufferSize),
+            to: totalRowCount
+        };
+        else return {
+            from: from - bufferSize,
+            to: to + bufferSize
+        };
+    }
+}
+const withinRange = (value, { from, to })=>value >= from && value < to;
+const rangeNewItems = ({ from: from1, to: to1 }, newRange)=>{
+    const { from: from2, to: to2 } = newRange;
+    const noOverlap = from2 >= to1 || to2 <= from1;
+    const newFullySubsumesOld = from2 < from1 && to2 > to1;
+    return noOverlap || newFullySubsumesOld ? newRange : to2 > to1 ? {
+        from: to1,
+        to: to2
+    } : {
+        from: from2,
+        to: from1
+    };
+};
+class WindowRange {
+    from;
+    to;
+    constructor(from, to){
+        this.from = from;
+        this.to = to;
+    }
+    isWithin(index) {
+        return withinRange(index, this);
+    }
+    overlap(from, to) {
+        return from >= this.to || to < this.from ? [
+            0,
+            0
+        ] : [
+            Math.max(from, this.from),
+            Math.min(to, this.to)
+        ];
+    }
+    copy() {
+        return new WindowRange(this.from, this.to);
+    }
+}
+export { NULL_RANGE, Range, WindowRange, getFullRange, rangeNewItems, withinRange };