@macive/ui 0.0.1 → 0.0.3

package/dist/src/utilities/focus.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapFocusNextFocusableMenuItem = exports.wrapFocusPreviousFocusableMenuItem = exports.focusLastKeyboardFocusableNode = exports.findLastKeyboardFocusableNode = exports.focusFirstKeyboardFocusableNode = exports.findFirstKeyboardFocusableNode = exports.focusNextFocusableNode = exports.focusFirstFocusableNode = exports.findFirstFocusableNodeIncludingDisabled = exports.findFirstFocusableNode = exports.nextFocusableNode = exports.handleMouseUpByBlurring = void 0;
+const is_element_in_viewport_1 = require("./is-element-in-viewport");
+const FOCUSABLE_SELECTOR = 'a,frame,iframe,input:not([type=hidden]):not(:disabled),select:not(:disabled),textarea:not(:disabled),button:not([aria-disabled="true"]):not([tabindex="-1"]):not(:disabled),*[tabindex]';
+const KEYBOARD_FOCUSABLE_SELECTORS = 'a,frame,iframe,input:not([type=hidden]):not(:disabled),select:not(:disabled),textarea:not(:disabled),button:not([aria-disabled="true"]):not([tabindex="-1"]):not(:disabled),*[tabindex]:not([tabindex="-1"])';
+const MENUITEM_FOCUSABLE_SELECTORS = 'a[role="menuitem"],frame[role="menuitem"],iframe[role="menuitem"],input[role="menuitem"]:not([type=hidden]):not(:disabled),select[role="menuitem"]:not(:disabled),textarea[role="menuitem"]:not(:disabled),button[role="menuitem"]:not(:disabled),*[tabindex]:not([tabindex="-1"])';
+const handleMouseUpByBlurring = ({ currentTarget }) => currentTarget.blur();
+exports.handleMouseUpByBlurring = handleMouseUpByBlurring;
+function nextFocusableNode(node, filter) {
+    const allFocusableElements = [
+        //@ts-ignore
+        ...document.querySelectorAll(FOCUSABLE_SELECTOR),
+    ];
+    const sliceLocation = allFocusableElements.indexOf(node) + 1;
+    const focusableElementsAfterNode = allFocusableElements.slice(sliceLocation);
+    for (const focusableElement of focusableElementsAfterNode) {
+        if ((0, is_element_in_viewport_1.isElementInViewport)(focusableElement) &&
+            //@ts-ignore
+            (!filter || (filter && filter(focusableElement)))) {
+            return focusableElement;
+        }
+    }
+    return null;
+}
+exports.nextFocusableNode = nextFocusableNode;
+function findFirstFocusableNode(element, onlyDescendants = true) {
+    if (!onlyDescendants && matches(element, FOCUSABLE_SELECTOR)) {
+        return element;
+    }
+    return element.querySelector(FOCUSABLE_SELECTOR);
+}
+exports.findFirstFocusableNode = findFirstFocusableNode;
+// Popover needs to be able to find its activator even if it is disabled, which FOCUSABLE_SELECTOR doesn't support.
+function findFirstFocusableNodeIncludingDisabled(element) {
+    const focusableSelector = `a,button,frame,iframe,input:not([type=hidden]),select,textarea,*[tabindex]`;
+    if (matches(element, focusableSelector)) {
+        return element;
+    }
+    return element.querySelector(focusableSelector);
+}
+exports.findFirstFocusableNodeIncludingDisabled = findFirstFocusableNodeIncludingDisabled;
+function focusFirstFocusableNode(element, onlyDescendants = true) {
+    var _a;
+    (_a = findFirstFocusableNode(element, onlyDescendants)) === null || _a === void 0 ? void 0 : _a.focus();
+}
+exports.focusFirstFocusableNode = focusFirstFocusableNode;
+function focusNextFocusableNode(node, filter) {
+    const nextFocusable = nextFocusableNode(node, filter);
+    if (nextFocusable && nextFocusable instanceof HTMLElement) {
+        nextFocusable.focus();
+        return true;
+    }
+    return false;
+}
+exports.focusNextFocusableNode = focusNextFocusableNode;
+function findFirstKeyboardFocusableNode(element, onlyDescendants = true) {
+    if (!onlyDescendants && matches(element, KEYBOARD_FOCUSABLE_SELECTORS)) {
+        return element;
+    }
+    return element.querySelector(KEYBOARD_FOCUSABLE_SELECTORS);
+}
+exports.findFirstKeyboardFocusableNode = findFirstKeyboardFocusableNode;
+function focusFirstKeyboardFocusableNode(element, onlyDescendants = true) {
+    const firstFocusable = findFirstKeyboardFocusableNode(element, onlyDescendants);
+    if (firstFocusable) {
+        firstFocusable.focus();
+        return true;
+    }
+    return false;
+}
+exports.focusFirstKeyboardFocusableNode = focusFirstKeyboardFocusableNode;
+function findLastKeyboardFocusableNode(element, onlyDescendants = true) {
+    if (!onlyDescendants && matches(element, KEYBOARD_FOCUSABLE_SELECTORS)) {
+        return element;
+    }
+    const allFocusable = element.querySelectorAll(KEYBOARD_FOCUSABLE_SELECTORS);
+    return allFocusable[allFocusable.length - 1];
+}
+exports.findLastKeyboardFocusableNode = findLastKeyboardFocusableNode;
+function focusLastKeyboardFocusableNode(element, onlyDescendants = true) {
+    const lastFocusable = findLastKeyboardFocusableNode(element, onlyDescendants);
+    if (lastFocusable) {
+        lastFocusable.focus();
+        return true;
+    }
+    return false;
+}
+exports.focusLastKeyboardFocusableNode = focusLastKeyboardFocusableNode;
+function wrapFocusPreviousFocusableMenuItem(parentElement, currentFocusedElement) {
+    const allFocusableChildren = getMenuFocusableDescendants(parentElement);
+    const currentItemIdx = getCurrentFocusedElementIndex(allFocusableChildren, currentFocusedElement);
+    if (currentItemIdx === -1) {
+        allFocusableChildren[0].focus();
+    }
+    else {
+        allFocusableChildren[(currentItemIdx - 1 + allFocusableChildren.length) % allFocusableChildren.length].focus();
+    }
+}
+exports.wrapFocusPreviousFocusableMenuItem = wrapFocusPreviousFocusableMenuItem;
+function wrapFocusNextFocusableMenuItem(parentElement, currentFocusedElement) {
+    const allFocusableChildren = getMenuFocusableDescendants(parentElement);
+    const currentItemIdx = getCurrentFocusedElementIndex(allFocusableChildren, currentFocusedElement);
+    if (currentItemIdx === -1) {
+        allFocusableChildren[0].focus();
+    }
+    else {
+        allFocusableChildren[(currentItemIdx + 1) % allFocusableChildren.length].focus();
+    }
+}
+exports.wrapFocusNextFocusableMenuItem = wrapFocusNextFocusableMenuItem;
+function getMenuFocusableDescendants(element) {
+    return element.querySelectorAll(MENUITEM_FOCUSABLE_SELECTORS);
+}
+function getCurrentFocusedElementIndex(allFocusableChildren, currentFocusedElement) {
+    let currentItemIdx = 0;
+    //@ts-ignore
+    for (const focusableChild of allFocusableChildren) {
+        if (focusableChild === currentFocusedElement) {
+            break;
+        }
+        currentItemIdx++;
+    }
+    return currentItemIdx === allFocusableChildren.length ? -1 : currentItemIdx;
+}
+function matches(node, selector) {
+    if (node.matches) {
+        return node.matches(selector);
+    }
+    const matches = (node.ownerDocument || document).querySelectorAll(selector);
+    let i = matches.length;
+    while (--i >= 0 && matches.item(i) !== node)
+        return i > -1;
+}

package/dist/src/utilities/frame/context.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FrameContext = void 0;
+const react_1 = require("react");
+exports.FrameContext = (0, react_1.createContext)(undefined);

package/dist/src/utilities/frame/hooks.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useFrame = void 0;
+const react_1 = require("react");
+const context_1 = require("./context");
+function useFrame() {
+    const frame = (0, react_1.useContext)(context_1.FrameContext);
+    if (!frame) {
+        throw new Error('No Frame context was provided. Your component must be wrapped in a <Frame> component. See https://dev.airsoko.com/components/frame for implementation instructions.');
+    }
+    return frame;
+}
+exports.useFrame = useFrame;

package/dist/src/utilities/frame/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./hooks"), exports);
+__exportStar(require("./context"), exports);

package/dist/src/utilities/frame/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/utilities/generateResponsiveSpacing.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateResponsiveSpacing = void 0;
+/**
+ * Generates responsive spacing classes based on the provided configuration.
+ * @param {Record<string, string | undefined> | string} spacingConfig - An object containing size-specific spacing values or a string value.
+ * @param {'p' | 'pt' | 'pb' | 'pr' | 'pl' | 'm' | 'mt' | 'mb' | 'mr' | 'ml'} spacingType - The spacing type.
+ * @returns {string} A string containing the generated spacing classes.
+ * @example
+ * // Using an object configuration
+ * const paddingConfig = {
+ *   xs: "2",
+ *   sm: "3",
+ *   md: "8",
+ *   lg: "8",
+ *   xl: "8",
+ * };
+ * const paddingClasses = generateResponsiveSpacing(paddingConfig, 'p');
+ * console.log(paddingClasses); // Output: "xs:p-2 sm:p-3 md:p-8 lg:p-8 xl:p-8"
+ *
+ * // Using a string value
+ * const marginClasses = generateResponsiveSpacing("4", 'm');
+ * console.log(marginClasses); // Output: "m-4"
+ */
+function generateResponsiveSpacing(spacingConfig, spacingType) {
+    if (typeof spacingConfig === "string") {
+        return `${spacingType}-${spacingConfig}`;
+    }
+    const sizes = ["xs", "sm", "md", "lg", "xl"];
+    const spacingClasses = sizes
+        .map((size) => {
+        const sizeValue = spacingConfig[size];
+        if (sizeValue) {
+            return `${size === "xs" ? "" : size + ":"}${spacingType}-${sizeValue}`;
+        }
+        return null;
+    })
+        .filter(Boolean);
+    return spacingClasses.join(" ");
+}
+exports.generateResponsiveSpacing = generateResponsiveSpacing;

package/dist/src/utilities/geometry.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRectForNode = exports.Rect = void 0;
+class Rect {
+    static get zero() {
+        return new Rect();
+    }
+    constructor({ top = 0, left = 0, width = 0, height = 0 } = {}) {
+        this.top = top;
+        this.left = left;
+        this.width = width;
+        this.height = height;
+    }
+    get center() {
+        return {
+            x: this.left + this.width / 2,
+            y: this.top + this.height / 2,
+        };
+    }
+}
+exports.Rect = Rect;
+function getRectForNode(node) {
+    if (!(node instanceof Element)) {
+        return new Rect({
+            width: window.innerWidth,
+            height: window.innerHeight,
+        });
+    }
+    const rect = node.getBoundingClientRect();
+    return new Rect({
+        top: rect.top,
+        left: rect.left,
+        width: rect.width,
+        height: rect.height,
+    });
+}
+exports.getRectForNode = getRectForNode;

package/dist/src/utilities/get-width.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWidth = void 0;
+const pluck_deep_1 = require("./pluck-deep");
+function getWidth(value = {}, defaultWidth = 0, key = 'width') {
+    const width = typeof value === 'number' ? value : (0, pluck_deep_1.pluckDeep)(value, key);
+    return width ? `${width}px` : `${defaultWidth}px`;
+}
+exports.getWidth = getWidth;

package/dist/src/utilities/get.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.get = void 0;
+const OBJECT_NOTATION_MATCHER = /\[(.*?)\]|(\w+)/g;
+function get(obj, keypath, defaultValue) {
+    if (obj == null)
+        return undefined;
+    const keys = Array.isArray(keypath) ? keypath : getKeypath(keypath);
+    let acc = obj;
+    // eslint-disable-next-line @typescript-eslint/prefer-for-of
+    for (let i = 0; i < keys.length; i++) {
+        const val = acc[keys[i]];
+        if (val === undefined)
+            return defaultValue;
+        acc = val;
+    }
+    return acc;
+}
+exports.get = get;
+function getKeypath(str) {
+    const path = [];
+    let result;
+    while ((result = OBJECT_NOTATION_MATCHER.exec(str))) {
+        const [, first, second] = result;
+        path.push(first || second);
+    }
+    return path;
+}

package/dist/src/utilities/i18n/I18n.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.I18n = void 0;
+const get_1 = require("../get");
+const merge_1 = require("../merge");
+const REPLACE_REGEX = /{([^}]*)}/g;
+class I18n {
+    /**
+     * @param translation A locale object or array of locale objects that overrides default translations. If specifying an array then your desired language dictionary should come first, followed by your fallback language dictionaries
+     */
+    constructor(translation) {
+        this.translation = {};
+        // slice the array to make a shallow copy of it, so we don't accidentally
+        // modify the original translation array
+        this.translation = Array.isArray(translation)
+            ? (0, merge_1.merge)(...translation.slice().reverse())
+            : translation;
+    }
+    translate(id, replacements) {
+        const text = (0, get_1.get)(this.translation, id, '');
+        if (!text) {
+            return '';
+        }
+        if (replacements) {
+            return text.replace(REPLACE_REGEX, (match) => {
+                const replacement = match.substring(1, match.length - 1);
+                if (replacements[replacement] === undefined) {
+                    const replacementData = JSON.stringify(replacements);
+                    throw new Error(`Error in translation for key '${id}'. No replacement found for key '${replacement}'. The following replacements were passed: '${replacementData}'`);
+                }
+                // This could be a string or a number, but JS doesn't mind which it gets
+                // and can handle that cast internally. So let it, to save us calling
+                // toString() on what's already a string in 90% of cases.
+                return replacements[replacement];
+            });
+        }
+        return text;
+    }
+    translationKeyExists(path) {
+        return Boolean((0, get_1.get)(this.translation, path));
+    }
+}
+exports.I18n = I18n;

package/dist/src/utilities/i18n/context.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.I18nContext = void 0;
+const react_1 = require("react");
+exports.I18nContext = (0, react_1.createContext)(undefined);

package/dist/src/utilities/i18n/hooks.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useI18n = void 0;
+const react_1 = require("react");
+const errors_1 = require("../errors");
+const context_1 = require("./context");
+function useI18n() {
+    const i18n = (0, react_1.useContext)(context_1.I18nContext);
+    if (!i18n) {
+        throw new errors_1.MissingAppProviderError('No i18n was provided.');
+    }
+    return i18n;
+}
+exports.useI18n = useI18n;

package/dist/src/utilities/i18n/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./context"), exports);
+__exportStar(require("./hooks"), exports);
+__exportStar(require("./I18n"), exports);

package/dist/src/utilities/index-provider/context.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexRowContext = exports.IndexSelectionChangeContext = exports.IndexContext = void 0;
+const react_1 = require("react");
+exports.IndexContext = (0, react_1.createContext)(undefined);
+exports.IndexSelectionChangeContext = (0, react_1.createContext)(undefined);
+exports.IndexRowContext = (0, react_1.createContext)(undefined);

package/dist/src/utilities/index-provider/hooks.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useHandleBulkSelection = exports.useBulkSelectionData = exports.useIndexValue = exports.useIndexRow = exports.useIndexSelectionChange = void 0;
+const react_1 = require("react");
+const i18n_1 = require("../i18n");
+const types_1 = require("./types");
+const context_1 = require("./context");
+function useIndexSelectionChange() {
+    const onSelectionChange = (0, react_1.useContext)(context_1.IndexSelectionChangeContext);
+    if (!onSelectionChange) {
+        throw new Error(`Missing IndexProvider context`);
+    }
+    return onSelectionChange;
+}
+exports.useIndexSelectionChange = useIndexSelectionChange;
+function useIndexRow() {
+    const indexRow = (0, react_1.useContext)(context_1.IndexRowContext);
+    if (!indexRow) {
+        throw new Error(`Missing IndexProvider context`);
+    }
+    return indexRow;
+}
+exports.useIndexRow = useIndexRow;
+function useIndexValue() {
+    const index = (0, react_1.useContext)(context_1.IndexContext);
+    if (!index) {
+        throw new Error(`Missing IndexProvider context`);
+    }
+    return index;
+}
+exports.useIndexValue = useIndexValue;
+function useBulkSelectionData({ selectedItemsCount, itemCount, hasMoreItems, resourceName: passedResourceName, }) {
+    const i18n = (0, i18n_1.useI18n)();
+    const selectable = Boolean(selectedItemsCount);
+    const selectMode = selectedItemsCount === 'All' || selectedItemsCount > 0;
+    const defaultResourceName = {
+        singular: i18n.translate('Polaris.IndexProvider.defaultItemSingular'),
+        plural: i18n.translate('Polaris.IndexProvider.defaultItemPlural'),
+    };
+    const resourceName = passedResourceName
+        ? passedResourceName
+        : defaultResourceName;
+    const paginatedSelectAllText = getPaginatedSelectAllText();
+    const bulkActionsLabel = getBulkActionsLabel();
+    const bulkActionsAccessibilityLabel = getBulkActionsAccessibilityLabel();
+    let bulkSelectState = 'indeterminate';
+    if (!selectedItemsCount || selectedItemsCount === 0) {
+        bulkSelectState = undefined;
+    }
+    else if (selectedItemsCount === types_1.SELECT_ALL_ITEMS ||
+        selectedItemsCount === itemCount) {
+        bulkSelectState = true;
+    }
+    return {
+        paginatedSelectAllText,
+        bulkActionsLabel,
+        bulkActionsAccessibilityLabel,
+        resourceName,
+        selectMode,
+        bulkSelectState,
+        selectable,
+    };
+    function getPaginatedSelectAllText() {
+        if (!selectable || !hasMoreItems) {
+            return;
+        }
+        if (selectedItemsCount === types_1.SELECT_ALL_ITEMS) {
+            return i18n.translate('Polaris.IndexProvider.allItemsSelected', {
+                itemsLength: itemCount,
+                resourceNamePlural: resourceName.plural.toLocaleLowerCase(),
+            });
+        }
+    }
+    function getBulkActionsLabel() {
+        const selectedItemsCountLabel = selectedItemsCount === types_1.SELECT_ALL_ITEMS
+            ? `${itemCount}+`
+            : selectedItemsCount;
+        return i18n.translate('Polaris.IndexProvider.selected', {
+            selectedItemsCount: selectedItemsCountLabel,
+        });
+    }
+    function getBulkActionsAccessibilityLabel() {
+        const totalItemsCount = itemCount;
+        const allSelected = selectedItemsCount === totalItemsCount;
+        if (totalItemsCount === 1 && allSelected) {
+            return i18n.translate('Polaris.IndexProvider.a11yCheckboxDeselectAllSingle', {
+                resourceNameSingular: resourceName.singular,
+            });
+        }
+        else if (totalItemsCount === 1) {
+            return i18n.translate('Polaris.IndexProvider.a11yCheckboxSelectAllSingle', {
+                resourceNameSingular: resourceName.singular,
+            });
+        }
+        else if (allSelected) {
+            return i18n.translate('Polaris.IndexProvider.a11yCheckboxDeselectAllMultiple', {
+                itemsLength: itemCount,
+                resourceNamePlural: resourceName.plural,
+            });
+        }
+        else {
+            return i18n.translate('Polaris.IndexProvider.a11yCheckboxSelectAllMultiple', {
+                itemsLength: itemCount,
+                resourceNamePlural: resourceName.plural,
+            });
+        }
+    }
+}
+exports.useBulkSelectionData = useBulkSelectionData;
+function useHandleBulkSelection({ onSelectionChange = () => { }, }) {
+    const lastSelected = (0, react_1.useRef)(null);
+    const handleSelectionChange = (0, react_1.useCallback)((selectionType, toggleType, selection, sortOrder) => {
+        const prevSelected = lastSelected.current;
+        if (types_1.SelectionType.Multi && typeof sortOrder === 'number') {
+            lastSelected.current = sortOrder;
+        }
+        if (selectionType === types_1.SelectionType.Single ||
+            (selectionType === types_1.SelectionType.Multi &&
+                (typeof prevSelected !== 'number' || typeof sortOrder !== 'number'))) {
+            onSelectionChange(types_1.SelectionType.Single, toggleType, selection);
+        }
+        else if (selectionType === types_1.SelectionType.Multi) {
+            const min = Math.min(prevSelected, sortOrder);
+            const max = Math.max(prevSelected, sortOrder);
+            onSelectionChange(selectionType, toggleType, [min, max]);
+        }
+        else if (selectionType === types_1.SelectionType.Page ||
+            selectionType === types_1.SelectionType.All) {
+            onSelectionChange(selectionType, toggleType);
+        }
+    }, [onSelectionChange]);
+    return handleSelectionChange;
+}
+exports.useHandleBulkSelection = useHandleBulkSelection;

package/dist/src/utilities/index-provider/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./hooks"), exports);
+__exportStar(require("./context"), exports);
+__exportStar(require("./types"), exports);

package/dist/src/utilities/index-provider/types.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SelectionType = exports.SELECT_ALL_ITEMS = void 0;
+exports.SELECT_ALL_ITEMS = 'All';
+var SelectionType;
+(function (SelectionType) {
+    SelectionType["All"] = "all";
+    SelectionType["Page"] = "page";
+    SelectionType["Multi"] = "multi";
+    SelectionType["Single"] = "single";
+})(SelectionType = exports.SelectionType || (exports.SelectionType = {}));

package/dist/src/utilities/index-table/context.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScrollContext = exports.scrollDefaultContext = exports.RowHoveredContext = exports.RowContext = void 0;
+const react_1 = require("react");
+exports.RowContext = (0, react_1.createContext)({});
+exports.RowHoveredContext = (0, react_1.createContext)(undefined);
+exports.scrollDefaultContext = {
+    scrollableContainer: null,
+    canScrollLeft: false,
+    canScrollRight: false,
+};
+exports.ScrollContext = (0, react_1.createContext)(exports.scrollDefaultContext);

package/dist/src/utilities/index-table/hooks.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useContainerScroll = exports.useRowSelected = exports.useRowHovered = void 0;
+const react_1 = require("react");
+const context_1 = require("./context");
+function useRowHovered() {
+    const hovered = (0, react_1.useContext)(context_1.RowHoveredContext);
+    return hovered;
+}
+exports.useRowHovered = useRowHovered;
+function useRowSelected() {
+    const { selected } = (0, react_1.useContext)(context_1.RowContext);
+    return selected;
+}
+exports.useRowSelected = useRowSelected;
+function useContainerScroll() {
+    const scrolledContainerRef = (0, react_1.useContext)(context_1.ScrollContext);
+    return scrolledContainerRef;
+}
+exports.useContainerScroll = useContainerScroll;

package/dist/src/utilities/index-table/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./hooks"), exports);
+__exportStar(require("./context"), exports);

package/dist/src/utilities/is-element-in-viewport.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isElementInViewport = void 0;
+function isElementInViewport(element) {
+    const { top, left, bottom, right } = element.getBoundingClientRect();
+    return (top >= 0 &&
+        right <= window.innerWidth &&
+        bottom <= window.innerHeight &&
+        left >= 0);
+}
+exports.isElementInViewport = isElementInViewport;

package/dist/src/utilities/is-input-focused.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInputFocused = void 0;
+var EditableTarget;
+(function (EditableTarget) {
+    EditableTarget["Input"] = "INPUT";
+    EditableTarget["Textarea"] = "TEXTAREA";
+    EditableTarget["Select"] = "SELECT";
+    EditableTarget["ContentEditable"] = "contenteditable";
+})(EditableTarget || (EditableTarget = {}));
+function isInputFocused() {
+    if (document == null || document.activeElement == null) {
+        return false;
+    }
+    const { tagName } = document.activeElement;
+    return (tagName === EditableTarget.Input ||
+        tagName === EditableTarget.Textarea ||
+        tagName === EditableTarget.Select ||
+        document.activeElement.hasAttribute(EditableTarget.ContentEditable));
+}
+exports.isInputFocused = isInputFocused;

package/dist/src/utilities/is-interface.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isInterface = void 0;
+const react_1 = require("react");
+function isInterface(x) {
+    return !(0, react_1.isValidElement)(x) && x !== undefined;
+}
+exports.isInterface = isInterface;