@ozen-ui/responsive 0.84.0

package/__inner__/esm/fabric/fabric.js

@@ -0,0 +1,75 @@
+import { __assign, __read, __spreadArray } from "tslib";
+import React from 'react';
+import { useBreakpoint as useBreakpointLibrary, useBreakpointObserver as useBreakpointObserverLibrary, useDeviceType as useDeviceTypeLibrary, useDeviceTypeObserver as useDeviceTypeObserverLibrary, useOrientation as useOrientationLibrary, useOrientationObserver as useOrientationObserverLibrary, useOS as useOSLibrary, useOSObserver as useOSObserverLibrary, useViewport as useViewportLibrary, useViewportObserver as useViewportObserverLibrary, } from '../hooks';
+import { ResponsiveProvider } from '../provider';
+import { ResponsiveNodes, ResponsiveProps } from '../ui';
+import { createScope } from './utils';
+export var createResponsive = function (breakpoints) {
+    var scope = createScope(breakpoints);
+    // ui
+    var ResponsivePropsComponent = function (props) { return React.createElement(ResponsiveProps, __assign({}, props)); };
+    var ResponsiveNodesComponent = function (props) { return React.createElement(ResponsiveNodes, __assign({}, props)); };
+    // Provider
+    var ProviderComponent = function (props) { return React.createElement(ResponsiveProvider, __assign({}, props, { scope: scope })); };
+    // hooks
+    var useBreakpoint = function () { return useBreakpointLibrary(); };
+    var useBreakpointObserver = function () {
+        var params = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            params[_i] = arguments[_i];
+        }
+        return useBreakpointObserverLibrary.apply(void 0, __spreadArray([], __read(params), false));
+    };
+    var useDeviceType = function () { return useDeviceTypeLibrary(); };
+    var useDeviceTypeObserver = function () {
+        var params = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            params[_i] = arguments[_i];
+        }
+        return useDeviceTypeObserverLibrary.apply(void 0, __spreadArray([], __read(params), false));
+    };
+    var useOrientation = function () { return useOrientationLibrary(); };
+    var useOrientationObserver = function () {
+        var params = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            params[_i] = arguments[_i];
+        }
+        return useOrientationObserverLibrary.apply(void 0, __spreadArray([], __read(params), false));
+    };
+    var useOS = function () { return useOSLibrary(); };
+    var useOSObserver = function () {
+        var params = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            params[_i] = arguments[_i];
+        }
+        return useOSObserverLibrary.apply(void 0, __spreadArray([], __read(params), false));
+    };
+    var useViewport = function () { return useViewportLibrary(); };
+    var useViewportObserver = function () {
+        var params = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            params[_i] = arguments[_i];
+        }
+        return useViewportObserverLibrary.apply(void 0, __spreadArray([], __read(params), false));
+    };
+    return {
+        breakpoints: breakpoints,
+        osVariant: scope.osVariant,
+        sizesAscending: scope.sizesAscending,
+        typeVariant: scope.typeVariant,
+        orientationVariant: scope.orientationVariant,
+        ResponsiveProps: ResponsivePropsComponent,
+        ResponsiveNodes: ResponsiveNodesComponent,
+        Provider: ProviderComponent,
+        useBreakpoint: useBreakpoint,
+        useBreakpointObserver: useBreakpointObserver,
+        useDeviceType: useDeviceType,
+        useDeviceTypeObserver: useDeviceTypeObserver,
+        useOrientation: useOrientation,
+        useOrientationObserver: useOrientationObserver,
+        useOS: useOS,
+        useOSObserver: useOSObserver,
+        useViewport: useViewport,
+        useViewportObserver: useViewportObserver,
+    };
+};

package/__inner__/esm/fabric/index.js

@@ -0,0 +1,2 @@
+export * from './infers';
+export * from './fabric';

package/__inner__/esm/fabric/infers/base.js

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

package/__inner__/esm/fabric/infers/breakpoint.js

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

package/__inner__/esm/fabric/infers/index.js

@@ -0,0 +1,5 @@
+export * from './breakpoint';
+export * from './orientation';
+export * from './os';
+export * from './type';
+export * from './viewport';

package/__inner__/esm/fabric/infers/orientation.js

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

package/__inner__/esm/fabric/infers/os.js

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

package/__inner__/esm/fabric/infers/type.js

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

package/__inner__/esm/fabric/infers/viewport.js

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

package/__inner__/esm/fabric/utils.js

@@ -0,0 +1,21 @@
+import { __read } from "tslib";
+import { orientation, OSVariant, type } from '../entities';
+export var createScope = function (breakpoints) {
+    var sizesAscending = Object.entries(breakpoints)
+        .sort(function (_a, _b) {
+        var _c = __read(_a, 2), breakpoint1 = _c[1];
+        var _d = __read(_b, 2), breakpoint2 = _d[1];
+        return breakpoint1 - breakpoint2;
+    })
+        .map(function (_a) {
+        var _b = __read(_a, 1), deviceSize = _b[0];
+        return deviceSize;
+    });
+    return {
+        breakpoints: breakpoints,
+        sizesAscending: sizesAscending,
+        osVariant: OSVariant,
+        orientationVariant: orientation,
+        typeVariant: type,
+    };
+};

package/__inner__/esm/hooks/index.js

@@ -0,0 +1,12 @@
+export * from './useBreakpoint';
+export * from './useBreakpointObserver';
+export * from './useDeviceType';
+export * from './useDeviceTypeObserver';
+export * from './useOrientation';
+export * from './useOrientationObserver';
+export * from './useOS';
+export * from './useOSObserver';
+export * from './useSnapshot';
+export * from './useSnapshotObserver';
+export * from './useViewport';
+export * from './useViewportObserver';

package/__inner__/esm/hooks/useBreakpoint.js

@@ -0,0 +1,12 @@
+import { __read } from "tslib";
+import { useState } from 'react';
+import { useResponsiveContext } from '../provider/ResponsiveContext';
+import { useBreakpointObserver } from './useBreakpointObserver';
+export var useBreakpoint = function () {
+    var store = useResponsiveContext().store;
+    var _a = __read(useState(function () { return store.snapshot.size; }), 2), breakpoint = _a[0], setBreakpoint = _a[1];
+    useBreakpointObserver(function (current) {
+        setBreakpoint(current);
+    });
+    return breakpoint;
+};

package/__inner__/esm/hooks/useBreakpointObserver.js

@@ -0,0 +1,15 @@
+import { useEventBusEvents } from "@ozen-ui/kit/useEventBusEvents";
+import { useStoredValue } from "@ozen-ui/kit/useStoredValue";
+import { useResponsiveContext } from '../provider/ResponsiveContext';
+export var useBreakpointObserver = function (onChange) {
+    var store = useResponsiveContext().store;
+    var breakpoints = useStoredValue(function () { return store.snapshot.size; });
+    useEventBusEvents(store.eventBus, {
+        breakpointChange: function (_a) {
+            var previous = _a.previous, current = _a.current;
+            breakpoints.current = current.size;
+            onChange === null || onChange === void 0 ? void 0 : onChange(current.size, previous.size);
+        },
+    });
+    return breakpoints;
+};

package/__inner__/esm/hooks/useDeviceType.js

@@ -0,0 +1,12 @@
+import { __read } from "tslib";
+import { useState } from 'react';
+import { useResponsiveContext } from '../provider/ResponsiveContext';
+import { useDeviceTypeObserver } from './useDeviceTypeObserver';
+export var useDeviceType = function () {
+    var store = useResponsiveContext().store;
+    var _a = __read(useState(function () { return store.snapshot.type; }), 2), type = _a[0], setType = _a[1];
+    useDeviceTypeObserver(function (current) {
+        setType(current);
+    });
+    return type;
+};

package/__inner__/esm/hooks/useDeviceTypeObserver.js

@@ -0,0 +1,15 @@
+import { useEventBusEvents } from "@ozen-ui/kit/useEventBusEvents";
+import { useStoredValue } from "@ozen-ui/kit/useStoredValue";
+import { useResponsiveContext } from '../provider/ResponsiveContext';
+export var useDeviceTypeObserver = function (onChange) {
+    var store = useResponsiveContext().store;
+    var type = useStoredValue(function () { return store.snapshot.type; });
+    useEventBusEvents(store.eventBus, {
+        typeChange: function (_a) {
+            var previous = _a.previous, current = _a.current;
+            type.current = current.type;
+            onChange === null || onChange === void 0 ? void 0 : onChange(current.type, previous.type);
+        },
+    });
+    return type;
+};

package/__inner__/esm/hooks/useOS.js

@@ -0,0 +1,12 @@
+import { __read } from "tslib";
+import { useState } from 'react';
+import { useResponsiveContext } from '../provider/ResponsiveContext';
+import { useOSObserver } from './useOSObserver';
+export var useOS = function () {
+    var store = useResponsiveContext().store;
+    var _a = __read(useState(function () { return store.snapshot.os; }), 2), OS = _a[0], setOS = _a[1];
+    useOSObserver(function (current) {
+        setOS(current);
+    });
+    return OS;
+};

package/__inner__/esm/hooks/useOSObserver.js

@@ -0,0 +1,15 @@
+import { useEventBusEvents } from "@ozen-ui/kit/useEventBusEvents";
+import { useStoredValue } from "@ozen-ui/kit/useStoredValue";
+import { useResponsiveContext } from '../provider/ResponsiveContext';
+export var useOSObserver = function (onChange) {
+    var store = useResponsiveContext().store;
+    var os = useStoredValue(function () { return store.snapshot.os; });
+    useEventBusEvents(store.eventBus, {
+        osChange: function (_a) {
+            var previous = _a.previous, current = _a.current;
+            os.current = current.os;
+            onChange === null || onChange === void 0 ? void 0 : onChange(current.os, previous.os);
+        },
+    });
+    return os;
+};

package/__inner__/esm/hooks/useOrientation.js

@@ -0,0 +1,12 @@
+import { __read } from "tslib";
+import { useState } from 'react';
+import { useResponsiveContext } from '../provider/ResponsiveContext';
+import { useOrientationObserver } from './useOrientationObserver';
+export var useOrientation = function () {
+    var store = useResponsiveContext().store;
+    var _a = __read(useState(function () { return store.snapshot.orientation; }), 2), orientation = _a[0], setOrientation = _a[1];
+    useOrientationObserver(function (current) {
+        setOrientation(current);
+    });
+    return orientation;
+};

package/__inner__/esm/hooks/useOrientationObserver.js

@@ -0,0 +1,15 @@
+import { useEventBusEvents } from "@ozen-ui/kit/useEventBusEvents";
+import { useStoredValue } from "@ozen-ui/kit/useStoredValue";
+import { useResponsiveContext } from '../provider/ResponsiveContext';
+export var useOrientationObserver = function (onChange) {
+    var store = useResponsiveContext().store;
+    var orientation = useStoredValue(function () { return store.snapshot.orientation; });
+    useEventBusEvents(store.eventBus, {
+        orientationChange: function (_a) {
+            var previous = _a.previous, current = _a.current;
+            orientation.current = current.orientation;
+            onChange === null || onChange === void 0 ? void 0 : onChange(current.orientation, previous.orientation);
+        },
+    });
+    return orientation;
+};

package/__inner__/esm/hooks/useSnapshot.js

@@ -0,0 +1,12 @@
+import { __read } from "tslib";
+import { useState } from 'react';
+import { useResponsiveContext } from '../provider';
+import { useSnapshotObserver } from './useSnapshotObserver';
+export var useSnapshot = function () {
+    var store = useResponsiveContext().store;
+    var _a = __read(useState(function () { return store.snapshot; }), 2), snapshot = _a[0], setSnapshot = _a[1];
+    useSnapshotObserver(function (current) {
+        setSnapshot(current);
+    });
+    return snapshot;
+};

package/__inner__/esm/hooks/useSnapshotObserver.js

@@ -0,0 +1,15 @@
+import { useEventBusEvents } from "@ozen-ui/kit/useEventBusEvents";
+import { useStoredValue } from "@ozen-ui/kit/useStoredValue";
+import { useResponsiveContext } from '../provider';
+export var useSnapshotObserver = function (onChange) {
+    var store = useResponsiveContext().store;
+    var snapshot = useStoredValue(function () { return store.snapshot; });
+    useEventBusEvents(store.eventBus, {
+        snapshotChange: function (_a) {
+            var previous = _a.previous, current = _a.current;
+            snapshot.current = current;
+            onChange === null || onChange === void 0 ? void 0 : onChange(current, previous);
+        },
+    });
+    return snapshot;
+};

package/__inner__/esm/hooks/useViewport.js

@@ -0,0 +1,12 @@
+import { __read } from "tslib";
+import { useState } from 'react';
+import { useResponsiveContext } from '../provider/ResponsiveContext';
+import { useViewportObserver } from './useViewportObserver';
+export var useViewport = function () {
+    var store = useResponsiveContext().store;
+    var _a = __read(useState(function () { return store.snapshot.viewport; }), 2), viewport = _a[0], setViewport = _a[1];
+    useViewportObserver(function (current) {
+        setViewport(current);
+    });
+    return viewport;
+};

package/__inner__/esm/hooks/useViewportObserver.js

@@ -0,0 +1,15 @@
+import { useEventBusEvents } from "@ozen-ui/kit/useEventBusEvents";
+import { useStoredValue } from "@ozen-ui/kit/useStoredValue";
+import { useResponsiveContext } from '../provider/ResponsiveContext';
+export var useViewportObserver = function (onChange) {
+    var store = useResponsiveContext().store;
+    var viewport = useStoredValue(function () { return store.snapshot.viewport; });
+    useEventBusEvents(store.eventBus, {
+        viewportChange: function (_a) {
+            var previous = _a.previous, current = _a.current;
+            viewport.current = current.viewport;
+            onChange === null || onChange === void 0 ? void 0 : onChange(current.viewport, previous.viewport);
+        },
+    });
+    return viewport;
+};

package/__inner__/esm/index.js

@@ -0,0 +1 @@
+export * from './fabric';

package/__inner__/esm/provider/ResponsiveContext.js

@@ -0,0 +1,12 @@
+import { useContext, createContext } from 'react';
+import { isDev } from '../constants';
+// ToDo: сделать на стандартных брейкпоинтах ozen
+export var AutocompleteBaseContextDefaultValue = null;
+export var ResponsiveContext = createContext(AutocompleteBaseContextDefaultValue);
+export var useResponsiveContext = function () {
+    return useContext(ResponsiveContext);
+};
+// Именованный провайдер
+if (isDev) {
+    ResponsiveContext.displayName = 'ResponsiveContext';
+}

package/__inner__/esm/provider/ResponsiveProvider.js

@@ -0,0 +1,19 @@
+import React, { useEffect, useMemo } from 'react';
+import { useStoredValue } from "@ozen-ui/kit/useStoredValue";
+import { ResponsiveStore } from '../store';
+import { ResponsiveContext } from './ResponsiveContext';
+export var ResponsiveProvider = function (_a) {
+    var scope = _a.scope, children = _a.children;
+    var store = useStoredValue(function () { return new ResponsiveStore(scope); });
+    var memoizedContextValue = useMemo(function () { return ({
+        store: store.current,
+    }); }, [store]);
+    useEffect(function () {
+        var currentStore = store.current;
+        currentStore.mount();
+        return function () {
+            currentStore.unmount();
+        };
+    }, []);
+    return (React.createElement(ResponsiveContext.Provider, { value: memoizedContextValue }, children));
+};

package/__inner__/esm/provider/index.js

@@ -0,0 +1,3 @@
+export * from './ResponsiveContext';
+export * from './ResponsiveProvider';
+export * from './types';

package/__inner__/esm/provider/types.js

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

package/__inner__/esm/store/ResponsiveStore.js

@@ -0,0 +1,92 @@
+import { EventBus } from "@ozen-ui/kit/utils";
+import { userAgentParser } from '../user-agent';
+import { getBreakpointState, getOrientationState, getOSState, getTypeState, } from './utils';
+var ResponsiveStore = /** @class */ (function () {
+    function ResponsiveStore(scope) {
+        this.eventBus = new EventBus();
+        this.raf = 0;
+        this.cleanup = null;
+        this.scope = scope;
+        this.snapshot = this.getSnapshot();
+    }
+    ResponsiveStore.prototype.getSnapshot = function () {
+        var viewport = {
+            width: window.innerWidth,
+            height: window.innerHeight,
+        };
+        var deviceType = userAgentParser.deviceType, OSName = userAgentParser.OSName;
+        var orientation = getOrientationState(viewport);
+        var size = getBreakpointState(this.scope, viewport.width);
+        var type = getTypeState(this.scope, deviceType);
+        var os = getOSState(this.scope, OSName);
+        return {
+            viewport: viewport,
+            type: type,
+            os: os,
+            size: size,
+            orientation: orientation,
+        };
+    };
+    ResponsiveStore.prototype.mount = function () {
+        var _this = this;
+        var onResize = function () { return _this.schedule(); };
+        window.addEventListener('resize', onResize, { passive: true });
+        window.addEventListener('orientationchange', onResize, { passive: true });
+        this.cleanup = function () {
+            window.removeEventListener('resize', onResize);
+            window.removeEventListener('orientationchange', onResize);
+            if (_this.raf) {
+                window.cancelAnimationFrame(_this.raf);
+            }
+            _this.raf = 0;
+        };
+        this.snapshot = this.getSnapshot();
+    };
+    ResponsiveStore.prototype.unmount = function () {
+        var _a;
+        (_a = this.cleanup) === null || _a === void 0 ? void 0 : _a.call(this);
+        this.cleanup = null;
+    };
+    ResponsiveStore.prototype.notify = function () {
+        var _this = this;
+        this.raf = 0;
+        userAgentParser.update();
+        var next = this.getSnapshot();
+        var events = [];
+        if (next.orientation.current !== this.snapshot.orientation.current) {
+            events.push('orientationChange');
+        }
+        if (next.size.current !== this.snapshot.size.current) {
+            events.push('breakpointChange');
+        }
+        if (next.os.current !== this.snapshot.os.current) {
+            events.push('osChange');
+        }
+        if (next.type.current !== this.snapshot.type.current) {
+            events.push('typeChange');
+        }
+        if (next.viewport.width !== this.snapshot.viewport.width ||
+            next.viewport.height !== this.snapshot.viewport.height) {
+            events.push('viewportChange');
+        }
+        if (events.length > 0) {
+            events.push('snapshotChange');
+        }
+        events.forEach(function (event) {
+            _this.eventBus.publish(event, {
+                previous: _this.snapshot,
+                current: next,
+            });
+        });
+        this.snapshot = next;
+    };
+    ResponsiveStore.prototype.schedule = function () {
+        var _this = this;
+        if (this.raf) {
+            return;
+        }
+        this.raf = window.requestAnimationFrame(function () { return _this.notify(); });
+    };
+    return ResponsiveStore;
+}());
+export { ResponsiveStore };

package/__inner__/esm/store/index.js

@@ -0,0 +1,2 @@
+export * from './ResponsiveStore';
+export * from './utils';

package/__inner__/esm/store/types.js

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

package/__inner__/esm/store/utils.js

@@ -0,0 +1,62 @@
+import { capitalizeFirstLetter } from '@ozen-ui/kit/utils';
+export var getTypeState = function (scope, current) {
+    var typeState = {
+        current: current,
+    };
+    Object.values(scope.typeVariant).forEach(function (deviceType) {
+        typeState["is".concat(capitalizeFirstLetter(deviceType))] =
+            deviceType === current;
+    });
+    return typeState;
+};
+export var getOrientationState = function (_a) {
+    var width = _a.width, height = _a.height;
+    var isVertical = width < height;
+    var isHorizontal = !isVertical;
+    return {
+        isHorizontal: isHorizontal,
+        isVertical: isVertical,
+        current: isVertical ? 'vertical' : 'horizontal',
+    };
+};
+export var getBreakpointState = function (scope, width) {
+    var breakpointState = {};
+    var currentSizeIndex = 0;
+    for (var i = 0; i < scope.sizesAscending.length; i++) {
+        var size = scope.sizesAscending[i];
+        var breakpoint = scope.breakpoints[size];
+        if (i === 0 && width <= breakpoint) {
+            currentSizeIndex = i;
+            breakpointState.current = size;
+            break;
+        }
+        if (width >= breakpoint) {
+            currentSizeIndex = i;
+            breakpointState.current = size;
+        }
+        else {
+            break;
+        }
+    }
+    var writeIsKey = function (key, value) {
+        breakpointState[key] =
+            value;
+    };
+    scope.sizesAscending.forEach(function (deviceSize, index) {
+        writeIsKey("is".concat(deviceSize.toUpperCase()), currentSizeIndex === index);
+        writeIsKey("above".concat(deviceSize.toUpperCase()), currentSizeIndex > index);
+        writeIsKey("below".concat(deviceSize.toUpperCase()), currentSizeIndex < index);
+        writeIsKey("atOrAbove".concat(deviceSize.toUpperCase()), currentSizeIndex >= index);
+        writeIsKey("atOrBelow".concat(deviceSize.toUpperCase()), currentSizeIndex <= index);
+    });
+    return breakpointState;
+};
+export var getOSState = function (scope, current) {
+    var OSState = {
+        current: current,
+    };
+    Object.values(scope.osVariant).forEach(function (OS) {
+        OSState["is".concat(capitalizeFirstLetter(OS))] = OS === current;
+    });
+    return OSState;
+};

package/__inner__/esm/ui/ResponsiveNodes/ResponsiveNodes.js

@@ -0,0 +1,25 @@
+import React from 'react';
+import { isFunction } from '@ozen-ui/kit/utils';
+import { useBreakpoint, useDeviceType } from '../../hooks';
+import { useResponsiveContext } from '../../provider/ResponsiveContext';
+import { resolveBreakpoints } from '../utils/utils';
+export var ResponsiveNodes = function (_a) {
+    var _b;
+    var by = _a.by, fallback = _a.fallback;
+    var store = useResponsiveContext().store;
+    var breakpoint = useBreakpoint();
+    var type = useDeviceType();
+    var device = {
+        size: breakpoint.current,
+        type: type.current,
+    };
+    var Fallback = fallback !== null && fallback !== void 0 ? fallback : (function () { return null; });
+    var component = (_b = resolveBreakpoints(store.scope, by, device)) === null || _b === void 0 ? void 0 : _b.value;
+    if (!component) {
+        return React.createElement(Fallback, null);
+    }
+    if (isFunction(component)) {
+        return component();
+    }
+    return component;
+};

package/__inner__/esm/ui/ResponsiveNodes/index.js

@@ -0,0 +1,2 @@
+export * from './ResponsiveNodes';
+export * from './types';

package/__inner__/esm/ui/ResponsiveNodes/types.js

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

package/__inner__/esm/ui/ResponsiveProps/ResponsiveProps.js

@@ -0,0 +1,36 @@
+import { __assign } from "tslib";
+import React from 'react';
+import { isFunction } from '@ozen-ui/kit/utils';
+import { useBreakpoint, useDeviceType } from '../../hooks';
+import { useResponsiveContext } from '../../provider';
+import { resolveBreakpoints } from '../utils';
+export var ResponsiveProps = function (_a) {
+    var _b;
+    var component = _a.component, props = _a.props, sharedPropsProp = _a.sharedProps, fallback = _a.fallback;
+    var store = useResponsiveContext().store;
+    var breakpoint = useBreakpoint();
+    var type = useDeviceType();
+    var device = {
+        size: breakpoint.current,
+        type: type.current,
+    };
+    var Fallback = fallback !== null && fallback !== void 0 ? fallback : (function () { return null; });
+    var rawNeededProps = (_b = resolveBreakpoints(store.scope, props, device)) === null || _b === void 0 ? void 0 : _b.value;
+    if (!rawNeededProps) {
+        return React.createElement(Fallback, null);
+    }
+    var sharedProps = (function () {
+        if (!sharedPropsProp) {
+            return null;
+        }
+        if (isFunction(sharedPropsProp)) {
+            return sharedPropsProp();
+        }
+        return sharedPropsProp;
+    })();
+    var neededProps = isFunction(rawNeededProps)
+        ? rawNeededProps()
+        : rawNeededProps;
+    var Component = component;
+    return React.createElement(Component, __assign({}, sharedProps, neededProps));
+};

package/__inner__/esm/ui/ResponsiveProps/index.js

@@ -0,0 +1,2 @@
+export * from './ResponsiveProps';
+export * from './types';

package/__inner__/esm/ui/ResponsiveProps/types.js

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

package/__inner__/esm/ui/index.js

@@ -0,0 +1,2 @@
+export * from './ResponsiveNodes';
+export * from './ResponsiveProps';

package/__inner__/esm/ui/utils/index.js

@@ -0,0 +1,2 @@
+export * from './utils';
+export * from './types';

package/__inner__/esm/ui/utils/types.js

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