@macive/ui 0.0.1 → 0.0.2

package/dist/src/utilities/use-is-touch-device.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useIsTouchDevice = void 0;
+const react_1 = require("react");
+const use_event_listener_1 = require("./use-event-listener");
+function useIsTouchDevice() {
+    const [isTouchDevice, setIsTouchDevice] = (0, react_1.useState)(false);
+    const handleTouchStart = (0, react_1.useCallback)(() => setIsTouchDevice(true), []);
+    (0, use_event_listener_1.useEventListener)('touchstart', handleTouchStart);
+    return isTouchDevice;
+}
+exports.useIsTouchDevice = useIsTouchDevice;

package/dist/src/utilities/use-isomorphic-layout-effect.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useIsomorphicLayoutEffect = void 0;
+// eslint-disable-next-line no-restricted-imports
+const react_1 = require("react");
+const target_1 = require("./target");
+exports.useIsomorphicLayoutEffect = target_1.isServer ? react_1.useEffect : react_1.useLayoutEffect;

package/dist/src/utilities/use-lazy-ref.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLazyRef = void 0;
+const react_1 = require("react");
+const UNIQUE_IDENTIFIER = Symbol('unique_identifier');
+/**
+ * useLazyRef provides a lazy initial value, similar to lazy
+ * initial state the initialValue is the value used during
+ * initialization and disregarded after that. Use this hook
+ * for expensive initialization.
+ * @param initialValue - A function that will return the initial
+ * value and be disregarded after that
+ * @returns MutableRefObject<T> - Returns a ref object with the
+ * results from invoking initial value
+ * @example
+ * function ComponentExample() {
+ *  const title = useLazyRef(() => someExpensiveComputation());
+ *  return <h1>{title.current}</h1>;
+ * }
+ */
+function useLazyRef(initialValue) {
+    const lazyRef = (0, react_1.useRef)(UNIQUE_IDENTIFIER);
+    if (lazyRef.current === UNIQUE_IDENTIFIER) {
+        lazyRef.current = initialValue();
+    }
+    return lazyRef;
+}
+exports.useLazyRef = useLazyRef;

package/dist/src/utilities/use-on-value-change.js

@@ -0,0 +1,38 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useOnValueChange = void 0;
+const react_1 = __importStar(require("react"));
+function useOnValueChange(value, onChange) {
+    const tracked = react_1.default.useRef(value);
+    (0, react_1.useEffect)(() => {
+        const oldValue = tracked.current;
+        if (value !== tracked.current) {
+            tracked.current = value;
+            onChange(value, oldValue);
+        }
+    }, [value, onChange]);
+}
+exports.useOnValueChange = useOnValueChange;

package/dist/src/utilities/use-previous.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.usePrevious = void 0;
+const react_1 = require("react");
+/**
+ * Returns the previous value of a variable.
+ */
+function usePrevious(value) {
+    const ref = (0, react_1.useRef)();
+    (0, react_1.useEffect)(() => {
+        ref.current = value;
+    }, [value]);
+    return ref.current;
+}
+exports.usePrevious = usePrevious;

package/dist/src/utilities/use-toggle.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useToggle = void 0;
+const react_1 = require("react");
+/**
+ * Returns a stateful value, and a set of memoized functions to toggle it,
+ * set it to true and set it to false
+ */
+function useToggle(initialState) {
+    const [value, setState] = (0, react_1.useState)(initialState);
+    return {
+        value,
+        toggle: (0, react_1.useCallback)(() => setState((state) => !state), []),
+        setTrue: (0, react_1.useCallback)(() => setState(true), []),
+        setFalse: (0, react_1.useCallback)(() => setState(false), []),
+    };
+}
+exports.useToggle = useToggle;

package/dist/src/utilities/within-content-context.js

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

package/dist/src/utilities/within-filter-context.js

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

package/dist/src/utils/capitalize.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capitalize = void 0;
+function capitalize(word = '') {
+    const wordLower = word.toLowerCase();
+    return wordLower.charAt(0).toUpperCase() + wordLower.slice(1);
+}
+exports.capitalize = capitalize;

package/dist/src/utils/components.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConditionalRender = exports.ConditionalWrapper = exports.elementChildren = exports.isElementOfType = exports.wrapWithComponent = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+// Wraps `element` in `Component`, if it is not already an instance of
+// `Component`. If `props` is passed, those will be added as props on the
+// wrapped component. If `element` is null, the component is not wrapped.
+function wrapWithComponent(element, Component, props) {
+    if (element == null) {
+        return null;
+    }
+    return isElementOfType(element, Component) ? element : (0, jsx_runtime_1.jsx)(Component, { ...props, children: element });
+}
+exports.wrapWithComponent = wrapWithComponent;
+// In development, we compare based on the name of the function because
+// React Hot Loader proxies React components in order to make updates. In
+// production we can simply compare the components for equality.
+const isComponent = process.env.NODE_ENV === 'development'
+    ? hotReloadComponentCheck
+    : (AComponent, AnotherComponent) => AComponent === AnotherComponent;
+// Checks whether `element` is a React element of type `Component` (or one of
+// the passed components, if `Component` is an array of React components).
+function isElementOfType(element, Component) {
+    var _a;
+    if (element == null || !(0, react_1.isValidElement)(element) || typeof element.type === 'string') {
+        return false;
+    }
+    const { type: defaultType } = element;
+    // Type override allows components to bypass default wrapping behavior. Ex: Stack, ResourceList...
+    // See https://github.com/Airsoko/app-extension-libs/issues/996#issuecomment-710437088
+    const overrideType = (_a = element.props) === null || _a === void 0 ? void 0 : _a.__type__;
+    const type = overrideType || defaultType;
+    const Components = Array.isArray(Component) ? Component : [Component];
+    return Components.some((AComponent) => typeof type !== 'string' && isComponent(AComponent, type));
+}
+exports.isElementOfType = isElementOfType;
+// Returns all children that are valid elements as an array. Can optionally be
+// filtered by passing `predicate`.
+function elementChildren(children, predicate = () => true) {
+    return react_1.Children.toArray(children).filter((child) => (0, react_1.isValidElement)(child) && predicate(child));
+}
+exports.elementChildren = elementChildren;
+function ConditionalWrapper({ condition, wrapper, children, }) {
+    return condition ? wrapper(children) : children;
+}
+exports.ConditionalWrapper = ConditionalWrapper;
+function ConditionalRender({ condition, children }) {
+    return condition ? children : null;
+}
+exports.ConditionalRender = ConditionalRender;
+function hotReloadComponentCheck(AComponent, AnotherComponent) {
+    const componentName = AComponent.name;
+    const anotherComponentName = AnotherComponent.displayName;
+    return (AComponent === AnotherComponent ||
+        (Boolean(componentName) && componentName === anotherComponentName));
+}

package/dist/src/utils/css.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getResponsiveValue = exports.getResponsiveProps = exports.sanitizeCustomProperties = exports.variationName = exports.classNames = void 0;
+function classNames(...classes) {
+    return classes.filter(Boolean).join(' ');
+}
+exports.classNames = classNames;
+function variationName(name, value) {
+    return `${name}${value.charAt(0).toUpperCase()}${value.slice(1)}`;
+}
+exports.variationName = variationName;
+function sanitizeCustomProperties(styles) {
+    const nonNullValues = Object.entries(styles).filter(([_, value]) => value != null);
+    return nonNullValues.length ? Object.fromEntries(nonNullValues) : undefined;
+}
+exports.sanitizeCustomProperties = sanitizeCustomProperties;
+function getResponsiveProps(componentName, componentProp, tokenSubgroup, responsiveProp) {
+    if (!responsiveProp)
+        return {};
+    if (typeof responsiveProp === 'string') {
+        return {
+            [`--pc-${componentName}-${componentProp}-xs`]: `var(--p-${tokenSubgroup}-${responsiveProp})`,
+        };
+    }
+    return Object.fromEntries(Object.entries(responsiveProp).map(([breakpointAlias, aliasOrScale]) => [
+        `--pc-${componentName}-${componentProp}-${breakpointAlias}`,
+        `var(--p-${tokenSubgroup}-${aliasOrScale})`,
+    ]));
+}
+exports.getResponsiveProps = getResponsiveProps;
+function getResponsiveValue(componentName, componentProp, responsiveProp) {
+    if (!responsiveProp)
+        return {};
+    if (typeof responsiveProp === 'string') {
+        return {
+            [`--pc-${componentName}-${componentProp}-xs`]: responsiveProp,
+        };
+    }
+    return Object.fromEntries(Object.entries(responsiveProp).map(([breakpointAlias, responsiveValue]) => [
+        `--pc-${componentName}-${componentProp}-${breakpointAlias}`,
+        responsiveValue,
+    ]));
+}
+exports.getResponsiveValue = getResponsiveValue;

package/dist/src/utils/helpers.js

@@ -0,0 +1,334 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeNumbersAndLetters = exports.checkActive = exports.getUrlPath = exports.getJson = exports.isJSON = exports.getDate = exports.getScrollDiv = exports.getReplace = exports.getStripedHtml = exports.getStaticAsset = exports.getIconComponent = exports.getIcon = exports.getCurrency = exports.cn = exports.getScroll = exports.SITE_URL = exports.SITE_NAME = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+//@ts-nocheck
+_a = {
+    SITE_NAME: 'dddd',
+    SITE_URL: 'http://localhost:3000',
+}, exports.SITE_NAME = _a.SITE_NAME, exports.SITE_URL = _a.SITE_URL;
+/**
+ * Scrolls the window to the specified coordinates with a smooth transition.
+ * @param {number} x - The horizontal coordinate to scroll to.
+ * @param {number} y - The vertical coordinate to scroll to.
+ *
+ * @example
+ * getScroll(0, 500); // Scrolls the window to the coordinates (0, 500) with a smooth transition
+ */
+const getScroll = (...rest) => {
+    //@ts-ignore
+    window.scrollTo(...rest, {
+        behavior: 'smooth',
+    });
+};
+exports.getScroll = getScroll;
+/*
+ * Returns a string of class names for use in a HTML element.
+ * @param {...string} classes - The class names to include in the string.
+ * @returns {string} - The resulting string of class names.
+ *
+ * @example
+ * const class1 = 'class-1';
+ * const class2 = 'class-2';
+ * const class3 = 'class-3';
+ * cn(class1, class2, class3);
+ * // Output: 'class-1 class-2 class-3'
+ */
+const cn = (...classes) => {
+    //@ts-ignore
+    return classes.filter(Boolean).join(' ');
+};
+exports.cn = cn;
+/**
+ * Returns the current currency value from the `useCurrency` hook.
+ * @returns {string} - The current currency value.
+ *
+ * @example
+ * getCurrency();
+ * // Output: 'USD'
+ */
+const getCurrency = () => {
+    //   const { value } = useCurrency();
+    //   return value;
+    return 'USD';
+};
+exports.getCurrency = getCurrency;
+/**
+ * Returns an Icon component with the specified name and props, from a list of available icons.
+ * @param {Object} options - An object containing the options for the Icon component.
+ * @param {Object} options.iconList - An object containing the available Icon components.
+ * @param {string} options.iconName - The name of the Icon component to return.
+ * @param {Object} [options.rest] - The props to pass to the Icon component.
+ * @returns {React.ReactElement|null} - The resulting Icon component, or `null` if the specified `iconName` is not a valid React component in the `iconList`.
+ *
+ * @example
+ * const options = {
+ *   iconList: {
+ *     Star: () => <Star />,
+ *     Circle: () => <Circle />
+ *   },
+ *   iconName: 'Star',
+ *   color: '#ffa500',
+ *   size: 24
+ * };
+ * getIcon(options);
+ * // Output: <Star color="#ffa500" size={24} />
+ */
+const getIcon = ({ iconList, iconName, ...rest }) => {
+    const TagName = iconList[iconName];
+    return !!TagName ? (0, jsx_runtime_1.jsx)(TagName, { ...rest }) : null;
+};
+exports.getIcon = getIcon;
+/**
+ * Returns an Icon component with the specified name and props.
+ * @param {Object} options - An object containing the options for the Icon component.
+ * @param {string} options.iconName - The name of the Icon component to return.
+ * @param {Object} [options.rest] - The props to pass to the Icon component.
+ * @returns {React.ReactElement|null} - The resulting Icon component, or `null` if the specified `iconName` is not a valid React component.
+ *
+ * @example
+ * const options = {
+ *   iconName: 'Star',
+ *   color: '#ffa500',
+ *   size: 24
+ * };
+ * getIconComponent(options);
+ * // Output: <Star color="#ffa500" size={24} />
+ */
+const getIconComponent = ({ iconName, ...rest }) => {
+    const TagName = iconName;
+    return !!TagName ? (0, jsx_runtime_1.jsx)(TagName, { ...rest }) : null;
+};
+exports.getIconComponent = getIconComponent;
+/**
+ * Builds a query string from an object containing key-value pairs.
+ * @param {Object} values - An object containing the key-value pairs for the query string.
+ * @returns {string} - The resulting query string.
+ *
+ * @example
+ * const values = { name: 'John Doe', age: 32 };
+ * getQuery(values);
+ * // Output: 'name=John Doe&age=32'
+ */
+/**
+ * Returns the URL of a static asset.
+ * @param {string} asset - The name of the static asset.
+ * @returns {string} - The URL of the static asset.
+ *
+ * @example
+ * getStaticAsset('logo.png');
+ * // Output: '/static/logo.png'
+ */
+const getStaticAsset = (asset) => {
+    return `${asset}`;
+};
+exports.getStaticAsset = getStaticAsset;
+/**
+ * Removes HTML tags from a string.
+ * @param {string} html - The original string containing HTML tags.
+ * @returns {string} - The resulting string with the HTML tags removed.
+ *
+ * @example
+ * const html = '<p>This is a <strong>bold</strong> sentence.</p>';
+ * getStripedHtml(html);
+ * // Output: 'This is a bold sentence.'
+ */
+const getStripedHtml = (html) => {
+    var _a;
+    return (_a = html.replace(/<[^>]+>/g, '')) !== null && _a !== void 0 ? _a : '';
+};
+exports.getStripedHtml = getStripedHtml;
+/**
+ * Replaces specified words or phrases in a string with their corresponding replacement values.
+ * @param {string} str - The original string.
+ * @param {Array} [replaceArray] - An array of words or phrases to replace in the string.
+ * @param {Array} [replaceArrayValue] - An array of replacement values for the words or phrases in the `replaceArray` parameter.
+ * @returns {string} - The resulting string with the specified words or phrases replaced by their corresponding values.
+ *
+ * @example
+ * const str = 'ShopClues.com is a great website for shopping';
+ * const replaceArray = ['ShopClues.com', 'great'];
+ * const replaceArrayValue = ['Adibai', 'awesome'];
+ * getReplace(str, replaceArray, replaceArrayValue);
+ * // Output: 'Adibai is a awesome website for shopping'
+ */
+const getReplace = (str, replaceArray, replaceArrayValue) => {
+    const url = exports.SITE_URL.replace(/^(?:https?:\/\/)?(?:www\.)?/i, '').split('/')[0];
+    const toReplace = ['ShopClues.com', 'Adibai', 'adibai', 'Oglamo', 'OGLAMO'];
+    const toReplaceValue = [
+        url,
+        exports.SITE_NAME,
+        exports.SITE_NAME.toLowerCase(),
+        exports.SITE_NAME,
+        exports.SITE_NAME.toUpperCase(),
+    ];
+    const find = replaceArray && replaceArray !== null ? replaceArray : toReplace;
+    const replace = replaceArrayValue && replaceArrayValue !== null ? replaceArrayValue : toReplaceValue;
+    for (var i = find.length - 1; i >= 0; i--) {
+        str = str.replace(RegExp('\\b' + find[i].replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&') + '\\b', 'g'), replace[i]);
+    }
+    return str;
+};
+exports.getReplace = getReplace;
+/**
+ * scrolls to specific Element ID
+ * @param {string|Required} id the  element id to be scrolled  to
+ * @param {Number|0} offSet tunes the position where  it lands
+ */
+const getScrollDiv = (id, offSet) => {
+    function findPos(obj, top) {
+        var curTop = top !== null && top !== void 0 ? top : 0;
+        if (obj === null || obj === void 0 ? void 0 : obj.offsetParent) {
+            do {
+                curTop += obj.offsetTop;
+            } while ((obj = obj.offsetParent));
+            return [curTop];
+        }
+    }
+    return window.scroll(0, findPos(document.getElementById(id), offSet));
+};
+exports.getScrollDiv = getScrollDiv;
+/**
+ * Returns an object with a `addDays()` method that allows you to add a specified number of days to the current date.
+ * @returns {Object} - An object with an `addDays()` method.
+ *
+ * @example
+ * const date = getDate();
+ * date.addDays(1);
+ * // Output: Fri Dec 11 2022 13:57:35 GMT-0500 (Eastern Standard Time)
+ */
+const getDate = () => {
+    //@ts-ignore
+    const addDays = (days) => {
+        //@ts-ignore
+        return new Date(Date.now() + days * 24 * 60 * 60 * 1000);
+    };
+    return { addDays };
+};
+exports.getDate = getDate;
+/*
+ * Determines if a given string is a valid JSON string.
+ * @param {string} str - The string to be checked.
+ * @returns {boolean} - `true` if the string is a valid JSON string, `false` otherwise.
+ *
+ * @example
+ * isJSON('{"name": "John"}');
+ * // Output: true
+ */
+const isJSON = (str) => {
+    try {
+        //@ts-ignore
+        return JSON.parse(str) && !!str;
+    }
+    catch (e) {
+        return false;
+    }
+};
+exports.isJSON = isJSON;
+/**
+ * Parses a JSON string and returns the resulting object, or `null` if the string is not valid JSON.
+ * @param {string} str - The JSON string to parse.
+ * @returns {Object|null} - The resulting object, or `null` if the string is not valid JSON.
+ *
+ * @example
+ * getJson('{"name": "John Doe", "age": 32}');
+ * // Output: { name: 'John Doe', age: 32 }
+ *
+ * getJson('invalid JSON string');
+ * // Output: null
+ */
+const getJson = (str) => {
+    try {
+        if (JSON.parse(str) && !!str) {
+            return JSON.parse(str) && !!str;
+        }
+    }
+    catch (e) {
+        return null;
+    }
+};
+exports.getJson = getJson;
+/**
+ * Replaces placeholder strings in a URL with their corresponding values from an object.
+ * @param {string} originalUrl - The original URL string with placeholder strings.
+ * @param {Object} replacements - An object that maps placeholder strings to their corresponding replacement values.
+ * @returns {string} - The URL string with the placeholders replaced by their corresponding values.
+ *
+ * @example
+ * const originalUrl = '/shop/[shopId]/products/[productId]';
+ * const replacements = {
+ *   shopId: '21',
+ *   productId: '3',
+ * };
+ * getUrlPath(originalUrl, replacements);
+ * // Output: '/shop/21/products/3'
+ */
+function getUrlPath(originalUrl, replacements) {
+    const newUrl = originalUrl.replace(/\[([^\]]+)\]/g, (match, p1) => replacements[p1]);
+    return newUrl;
+}
+exports.getUrlPath = getUrlPath;
+/**
+ * Compares the placeholder strings in a URL with the keys in an object.
+ * @param {Object} router - An object that contains the `pathname` and `query` properties.
+ * @returns {boolean} - Returns `true` if the placeholder strings in the URL match the keys in the object, or `false` if they do not match.
+ *
+ * @example
+ * const router = {
+ *   pathname: '/shop/[shopId]/products/[productId]',
+ *   query: {
+ *     shopId: '21',
+ *     productId: '3',
+ *   },
+ * };
+ * checkActive(router);
+ * // Output: true
+ */
+function checkActive(router) {
+    const originalUrl = router === null || router === void 0 ? void 0 : router.pathname;
+    const matches = originalUrl.match(/\[([^\]]+)\]/g);
+    const placeholderKeys = matches === null || matches === void 0 ? void 0 : matches.map((value) => value === null || value === void 0 ? void 0 : value.replace(/[\[\]]/g, ''));
+    const obj = router === null || router === void 0 ? void 0 : router.query;
+    const queryKeys = Object.keys(obj);
+    if (JSON.stringify(queryKeys) == JSON.stringify(placeholderKeys)) {
+        return true;
+    }
+    else {
+        return false;
+    }
+}
+exports.checkActive = checkActive;
+/**
+ * Removes the `undefined` string, the letters after the `?` character, and the brackets and letters inside the brackets in a string.
+ *
+ * @param {string} s - The input string.
+ * @returns {string} The resulting string.
+ *
+ * @example
+ * removeNumbersAndLetters("/shop/9/dd/undefined/products?status=PUBLISHED")
+ * // returns "/shop//dd/products"
+ */
+function removeNumbersAndLetters(s) {
+    // Split the string on the `?` character
+    let parts = s.split('?');
+    // Replace the matched digits with an empty string
+    parts[0] = parts[0].replace(/\d+/g, '');
+    // Use a regular expression to match the `undefined` string surrounded by forward slashes, and the letters after the `?` character
+    let regex = /\/undefined\/|\?.*/g;
+    // Replace the `undefined` string and the letters after the `?` in the first part of the string
+    parts[0] = parts[0].replace(regex, '//');
+    // Use a regular expression to match the pattern of forward slashes before the brackets
+    regex = /\/\[[a-zA-Z]+\]/g;
+    // Replace the forward slashes and the brackets with an empty string
+    parts[0] = parts[0].replace(regex, '');
+    // Remove the extra forward slash at the end of the string
+    // parts[0] = parts[0].slice(0, -1);
+    parts[0] = parts[0].replace(/\/$/, '');
+    // Use a regular expression to match any double slashes at the end of the string
+    regex = /\/\//g;
+    // Replace the double slashes with a single slash
+    parts[0] = parts[0].replace(regex, '/');
+    return parts[0];
+}
+exports.removeNumbersAndLetters = removeNumbersAndLetters;

package/dist/src/utils/index.js

@@ -0,0 +1,17 @@
+"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("./helpers"), exports);

package/dist/src/utils/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;

package/dist/src/utils/is-react-element.js

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

package/dist/src/utils/use-break-point.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useBreakpoint = void 0;
+const react_1 = require("react");
+const breakpoints = {
+    mobile: '100%',
+    tablet: '50%',
+    desktop: '50%',
+};
+const getBreakpointValue = (breakpoint) => breakpoints[breakpoint];
+const useBreakpoint = () => {
+    const [breakpoint, setBreakpoint] = (0, react_1.useState)('mobile');
+    (0, react_1.useEffect)(() => {
+        const handleResize = () => {
+            //@ts-ignore
+            const width = window.innerWidth;
+            if (width <= 640) {
+                setBreakpoint('mobile');
+            }
+            else if (width <= 1024) {
+                setBreakpoint('tablet');
+            }
+            else {
+                setBreakpoint('desktop');
+            }
+        };
+        //@ts-ignore
+        window.addEventListener('resize', handleResize);
+        return () => {
+            //@ts-ignore
+            window.removeEventListener('resize', handleResize);
+        };
+    }, []);
+    return { breakpoint, getBreakpointValue };
+};
+exports.useBreakpoint = useBreakpoint;