@ozen-ui/responsive 0.84.0

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

@@ -0,0 +1,74 @@
+/* eslint-disable no-continue */
+import { __read, __values } from "tslib";
+export var resolveBreakpoints = function (scope, by, device) {
+    var e_1, _a, e_2, _b;
+    var SIZE_RANK = {};
+    scope.sizesAscending.forEach(function (size, index) {
+        SIZE_RANK[size] = index;
+    });
+    var currentRank = SIZE_RANK[device.size];
+    var bestMixed = null;
+    try {
+        for (var _c = __values(Object.entries(by)), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var _e = __read(_d.value, 2), rawKey = _e[0], Comp = _e[1];
+            if (!Comp) {
+                continue;
+            }
+            var key = rawKey;
+            var parts = rawKey.split(':');
+            if (parts.length !== 2) {
+                continue;
+            }
+            var _f = __read(parts, 2), type = _f[0], size = _f[1];
+            if (type !== device.type) {
+                continue;
+            }
+            if (!(size in SIZE_RANK)) {
+                continue;
+            }
+            var rank = SIZE_RANK[size];
+            if (rank <= currentRank && (!bestMixed || rank > bestMixed.rank)) {
+                bestMixed = { key: key, rank: rank, value: Comp };
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    if (bestMixed) {
+        return { key: bestMixed.key, value: bestMixed.value };
+    }
+    var typeOnly = by[device.type];
+    if (typeOnly) {
+        return { key: device.type, value: typeOnly };
+    }
+    var bestSize = null;
+    try {
+        for (var _g = __values(scope.sizesAscending), _h = _g.next(); !_h.done; _h = _g.next()) {
+            var size = _h.value;
+            var value = by[size];
+            if (!value) {
+                continue;
+            }
+            var rank = SIZE_RANK[size];
+            if (rank <= currentRank && (!bestSize || rank > bestSize.rank)) {
+                bestSize = { key: size, rank: rank, value: value };
+            }
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_h && !_h.done && (_b = _g.return)) _b.call(_g);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+    if (bestSize) {
+        return { key: bestSize.key, value: bestSize.value };
+    }
+    return null;
+};

package/__inner__/esm/user-agent/constants.js

@@ -0,0 +1,112 @@
+var UADeviceType = {
+    CONSOLE: 'console',
+    DESKTOP: 'desktop',
+    EMBEDDED: 'embedded',
+    MOBILE: 'mobile',
+    SMARTTV: 'smarttv',
+    TABLET: 'tablet',
+    WEARABLE: 'wearable',
+    XR: 'xr',
+};
+var OSName = {
+    AIX: 'AIX',
+    AMIGA_OS: 'Amiga OS',
+    ANDROID: 'Android',
+    ANDROID_X86: 'Android-x86',
+    ARCAOS: 'ArcaOS',
+    ARCH: 'Arch',
+    BADA: 'Bada',
+    BEOS: 'BeOS',
+    BLACKBERRY: 'BlackBerry',
+    CENTOS: 'CentOS',
+    CHROME_OS: 'Chrome OS',
+    CHROMECAST: 'Chromecast',
+    CHROMECAST_ANDROID: 'Chromecast Android',
+    CHROMECAST_FUCHSIA: 'Chromecast Fuchsia',
+    CHROMECAST_LINUX: 'Chromecast Linux',
+    CHROMECAST_SMARTSPEAKER: 'Chromecast SmartSpeaker',
+    CONTIKI: 'Contiki',
+    DEBIAN: 'Debian',
+    DEEPIN: 'Deepin',
+    DRAGONFLY: 'DragonFly',
+    ELEMENTARY_OS: 'elementary OS',
+    FEDORA: 'Fedora',
+    FIREFOX_OS: 'Firefox OS',
+    FREEBSD: 'FreeBSD',
+    FUCHSIA: 'Fuchsia',
+    GENTOO: 'Gentoo',
+    GHOSTBSD: 'GhostBSD',
+    GNU: 'GNU',
+    HAIKU: 'Haiku',
+    HARMONYOS: 'HarmonyOS',
+    HP_UX: 'HP-UX',
+    HURD: 'Hurd',
+    IOS: 'iOS',
+    JOLI: 'Joli',
+    KAIOS: 'KaiOS',
+    KNOPPIX: 'Knoppix',
+    KUBUNTU: 'Kubuntu',
+    LINPUS: 'Linpus',
+    LINSPIRE: 'Linspire',
+    LINUX: 'Linux',
+    MACOS: 'macOS',
+    MAEMO: 'Maemo',
+    MAGEIA: 'Mageia',
+    MANDRIVA: 'Mandriva',
+    MANJARO: 'Manjaro',
+    MEEGO: 'MeeGo',
+    MINIX: 'Minix',
+    MINT: 'Mint',
+    MORPH_OS: 'Morph OS',
+    NETBSD: 'NetBSD',
+    NETRANGE: 'NetRange',
+    NETTV: 'NetTV',
+    NINTENDO: 'Nintendo',
+    OPENHARMONY: 'OpenHarmony',
+    OPENBSD: 'OpenBSD',
+    OPENVMS: 'OpenVMS',
+    OS2: 'OS/2',
+    PALM: 'Palm',
+    PC_BSD: 'PC-BSD',
+    PCLINUXOS: 'PCLinuxOS',
+    PICO: 'Pico',
+    PLAN9: 'Plan9',
+    PLAYSTATION: 'PlayStation',
+    QNX: 'QNX',
+    RASPBIAN: 'Raspbian',
+    REDHAT: 'RedHat',
+    RIM_TABLET_OS: 'RIM Tablet OS',
+    RISC_OS: 'RISC OS',
+    SABAYON: 'Sabayon',
+    SAILFISH: 'Sailfish',
+    SERENITYOS: 'SerenityOS',
+    SERIES40: 'Series40',
+    SLACKWARE: 'Slackware',
+    SOLARIS: 'Solaris',
+    SUSE: 'SUSE',
+    SYMBIAN: 'Symbian',
+    TIZEN: 'Tizen',
+    UBUNTU: 'Ubuntu',
+    UBUNTU_TOUCH: 'Ubuntu Touch',
+    UNIX: 'Unix',
+    VECTORLINUX: 'VectorLinux',
+    WATCHOS: 'watchOS',
+    WEBOS: 'WebOS',
+    WINDOWS: 'Windows',
+    WINDOWS_CE: 'Windows CE',
+    WINDOWS_IOT: 'Windows IoT',
+    WINDOWS_MOBILE: 'Windows Mobile',
+    WINDOWS_PHONE: 'Windows Phone',
+    WINDOWS_RT: 'Windows RT',
+    XBOX: 'Xbox',
+    XUBUNTU: 'Xubuntu',
+    ZENWALK: 'Zenwalk',
+};
+export var USER_AGENT_PARSER_OS_TO_INTERNAL_OS = {
+    macOS: ['macOS'],
+    ios: ['iOS'],
+};
+export var USER_AGENT_PARSER_TYPE_TO_INTERNAL_TYPE = {
+    mobile: ['mobile'],
+    tablet: ['tablet'],
+};

package/__inner__/esm/user-agent/index.js

@@ -0,0 +1,2 @@
+export * from './constants';
+export * from './user-agent-parser';

package/__inner__/esm/user-agent/user-agent-parser.js

@@ -0,0 +1,89 @@
+import { __read, __values } from "tslib";
+import { UAParser } from 'ua-parser-js';
+import { USER_AGENT_PARSER_OS_TO_INTERNAL_OS, USER_AGENT_PARSER_TYPE_TO_INTERNAL_TYPE, } from './constants';
+var UserAgentParser = /** @class */ (function () {
+    function UserAgentParser(userAgent) {
+        this.userAgent = new UAParser(userAgent);
+    }
+    UserAgentParser.prototype.update = function () {
+        this.userAgent = new UAParser();
+    };
+    Object.defineProperty(UserAgentParser.prototype, "deviceType", {
+        get: function () {
+            var e_1, _a;
+            var rawType = this.device.type;
+            if (!rawType) {
+                return 'desktop';
+            }
+            var _loop_1 = function (rawType_1, uaTypes) {
+                var type = rawType_1;
+                if (uaTypes.some(function (type) { return type === rawType_1; })) {
+                    return { value: type };
+                }
+            };
+            try {
+                for (var _b = __values(Object.entries(USER_AGENT_PARSER_TYPE_TO_INTERNAL_TYPE)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var _d = __read(_c.value, 2), rawType_1 = _d[0], uaTypes = _d[1];
+                    var state_1 = _loop_1(rawType_1, uaTypes);
+                    if (typeof state_1 === "object")
+                        return state_1.value;
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            return 'desktop';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(UserAgentParser.prototype, "OSName", {
+        get: function () {
+            var e_2, _a;
+            var rawName = this.OS.name;
+            if (!rawName) {
+                return 'unknown';
+            }
+            try {
+                for (var _b = __values(Object.entries(USER_AGENT_PARSER_OS_TO_INTERNAL_OS)), _c = _b.next(); !_c.done; _c = _b.next()) {
+                    var _d = __read(_c.value, 2), rawOS = _d[0], uaOS = _d[1];
+                    var OS = rawOS;
+                    if (uaOS.some(function (OS) { return OS === rawName; })) {
+                        return OS;
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            return 'unknown';
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(UserAgentParser.prototype, "device", {
+        get: function () {
+            return this.userAgent.getDevice();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    Object.defineProperty(UserAgentParser.prototype, "OS", {
+        get: function () {
+            return this.userAgent.getOS();
+        },
+        enumerable: false,
+        configurable: true
+    });
+    return UserAgentParser;
+}());
+export { UserAgentParser };
+export var userAgentParser = new UserAgentParser();

package/__inner__/types/constants/environment/constants/index.d.ts

@@ -0,0 +1,2 @@
+export * from './isDev';
+export * from './isProduction';

package/__inner__/types/constants/environment/constants/isDev.d.ts

@@ -0,0 +1 @@
+export declare const isDev: boolean;

package/__inner__/types/constants/environment/constants/isProduction.d.ts

@@ -0,0 +1 @@
+export declare const isProduction: boolean;

package/__inner__/types/constants/environment/index.d.ts

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

package/__inner__/types/constants/index.d.ts

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

package/__inner__/types/entities/breakpoint.d.ts

@@ -0,0 +1,21 @@
+import type { Type } from './type';
+export type Breakpoints = Record<string, number>;
+export type InternalInferBreakpoint<TBreakpoints extends Breakpoints> = keyof TBreakpoints & string;
+export type BreakpointState<TBreakpoints extends Breakpoints> = {
+    current: InternalInferBreakpoint<TBreakpoints>;
+} & {
+    [Size in InternalInferBreakpoint<TBreakpoints> as `is${Uppercase<Size>}`]: boolean;
+} & {
+    [Size in InternalInferBreakpoint<TBreakpoints> as `above${Uppercase<Size>}`]: boolean;
+} & {
+    [Size in InternalInferBreakpoint<TBreakpoints> as `below${Uppercase<Size>}`]: boolean;
+} & {
+    [Size in InternalInferBreakpoint<TBreakpoints> as `atOrAbove${Uppercase<Size>}`]: boolean;
+} & {
+    [Size in InternalInferBreakpoint<TBreakpoints> as `atOrBelow${Uppercase<Size>}`]: boolean;
+};
+export type BreakpointSimpleSize<TBreakpoints extends Breakpoints> = InternalInferBreakpoint<TBreakpoints>;
+export type BreakpointSimpleType = Type;
+export type BreakpointMixedKey<TBreakpoints extends Breakpoints> = `${BreakpointSimpleType}:${BreakpointSimpleSize<TBreakpoints>}`;
+export type BreakpointKey<TBreakpoints extends Breakpoints> = BreakpointSimpleSize<TBreakpoints> | BreakpointSimpleType | BreakpointMixedKey<TBreakpoints>;
+export type ByBreakpoints<TBreakpoints extends Breakpoints, Value> = Partial<Record<BreakpointKey<TBreakpoints>, Value>>;

package/__inner__/types/entities/index.d.ts

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

package/__inner__/types/entities/orientation.d.ts

@@ -0,0 +1,7 @@
+export declare const orientation: readonly ["horizontal", "vertical"];
+export type Orientation = (typeof orientation)[number];
+export type OrientationState = {
+    current: Orientation;
+} & {
+    [TOrientation in Orientation as `is${Capitalize<TOrientation>}`]: boolean;
+};

package/__inner__/types/entities/os.d.ts

@@ -0,0 +1,8 @@
+export declare const OSVariant: readonly ["macOS", "ios", "unknown"];
+export type OS = (typeof OSVariant)[number];
+export type OSStateKeyIs<TOS extends OS = OS> = `is${Capitalize<TOS>}`;
+export type OSState = {
+    [TOS in OS as OSStateKeyIs<TOS>]: boolean;
+} & {
+    current: OS;
+};

package/__inner__/types/entities/scope.d.ts

@@ -0,0 +1,11 @@
+import type { Breakpoints } from './breakpoint';
+import type { Orientation } from './orientation';
+import type { OS } from './os';
+import type { Type } from './type';
+export type Scope<TBreakpoints extends Breakpoints> = {
+    breakpoints: TBreakpoints;
+    sizesAscending: (keyof TBreakpoints & string)[];
+    osVariant: Readonly<OS[]>;
+    typeVariant: Readonly<Type[]>;
+    orientationVariant: Readonly<Orientation[]>;
+};

package/__inner__/types/entities/type.d.ts

@@ -0,0 +1,8 @@
+export declare const type: readonly ["mobile", "tablet", "desktop"];
+export type Type = (typeof type)[number];
+export type TypeStateKeyIs<TType extends Type = Type> = `is${Capitalize<TType>}`;
+export type TypeState = {
+    [TType in Type as TypeStateKeyIs<TType>]: boolean;
+} & {
+    current: Type;
+};

package/__inner__/types/entities/viewport.d.ts

@@ -0,0 +1,4 @@
+export type Viewport = {
+    width: number;
+    height: number;
+};

package/__inner__/types/fabric/fabric.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import type { ElementType } from 'react';
+import type { Breakpoints } from '../entities';
+import type { ResponsiveProviderProps } from '../provider';
+import type { ResponsiveNodesProps, ResponsivePropsProps } from '../ui';
+export declare const createResponsive: <TBreakpoints extends Breakpoints>(breakpoints: TBreakpoints) => {
+    breakpoints: TBreakpoints;
+    osVariant: readonly ("macOS" | "ios" | "unknown")[];
+    sizesAscending: (keyof TBreakpoints & string)[];
+    typeVariant: readonly ("mobile" | "tablet" | "desktop")[];
+    orientationVariant: readonly ("horizontal" | "vertical")[];
+    ResponsiveProps: <Component extends ElementType>(props: ResponsivePropsProps<TBreakpoints, Component>) => React.JSX.Element;
+    ResponsiveNodes: (props: ResponsiveNodesProps<TBreakpoints>) => React.JSX.Element;
+    Provider: (props: Omit<ResponsiveProviderProps<TBreakpoints>, "scope">) => React.JSX.Element;
+    useBreakpoint: () => import("../entities").BreakpointState<TBreakpoints>;
+    useBreakpointObserver: (onChange?: ((current: import("../entities").BreakpointState<Breakpoints>, previous: import("../entities").BreakpointState<Breakpoints>) => void) | undefined) => import("@ozen-ui/kit/useStoredValue").StoredValue<import("../entities").BreakpointState<TBreakpoints>>;
+    useDeviceType: () => import("../entities").TypeState;
+    useDeviceTypeObserver: (onChange?: ((current: import("../entities").TypeState, previous: import("../entities").TypeState) => void) | undefined) => import("@ozen-ui/kit/useStoredValue").StoredValue<import("../entities").TypeState>;
+    useOrientation: () => import("../entities").OrientationState;
+    useOrientationObserver: (onChange?: ((current: import("../entities").OrientationState, previous: import("../entities").OrientationState) => void) | undefined) => import("@ozen-ui/kit/useStoredValue").StoredValue<import("../entities").OrientationState>;
+    useOS: () => import("../entities").OSState;
+    useOSObserver: (onChange?: ((current: import("../entities").OSState, previous: import("../entities").OSState) => void) | undefined) => import("@ozen-ui/kit/useStoredValue").StoredValue<import("../entities").OSState>;
+    useViewport: () => import("../entities").Viewport;
+    useViewportObserver: (onChange?: ((current: import("../entities").Viewport, previous: import("../entities").Viewport) => void) | undefined) => import("@ozen-ui/kit/useStoredValue").StoredValue<import("../entities").Viewport>;
+};

package/__inner__/types/fabric/index.d.ts

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

package/__inner__/types/fabric/infers/base.d.ts

@@ -0,0 +1,2 @@
+import type { createResponsive } from '../fabric';
+export type FabricValue = ReturnType<typeof createResponsive>;

package/__inner__/types/fabric/infers/breakpoint.d.ts

@@ -0,0 +1,5 @@
+import type { BreakpointKey, BreakpointState, InternalInferBreakpoint } from '../../entities';
+import type { FabricValue } from './base';
+export type InferBreakpoint<Fabric extends FabricValue> = InternalInferBreakpoint<Fabric['breakpoints']>;
+export type InferBreakpointState<Fabric extends FabricValue> = BreakpointState<Fabric['breakpoints']>;
+export type InferBreakpointKey<Fabric extends FabricValue> = BreakpointKey<Fabric['breakpoints']>;

package/__inner__/types/fabric/infers/index.d.ts

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

package/__inner__/types/fabric/infers/orientation.d.ts

@@ -0,0 +1,4 @@
+import type { Orientation, OrientationState } from '../../entities';
+import type { FabricValue } from './base';
+export type InferOrientation<Fabric extends FabricValue> = Orientation;
+export type InferOrientationState<Fabric extends FabricValue> = OrientationState;

package/__inner__/types/fabric/infers/os.d.ts

@@ -0,0 +1,4 @@
+import type { OS, OSState } from '../../entities';
+import type { FabricValue } from './base';
+export type InferOS<Fabric extends FabricValue> = OS;
+export type InferOSState<Fabric extends FabricValue> = OSState;

package/__inner__/types/fabric/infers/type.d.ts

@@ -0,0 +1,4 @@
+import type { Type, TypeState } from '../../entities';
+import type { FabricValue } from './base';
+export type InferType<Fabric extends FabricValue> = Type;
+export type InferTypeState<Fabric extends FabricValue> = TypeState;

package/__inner__/types/fabric/infers/viewport.d.ts

@@ -0,0 +1,3 @@
+import type { Viewport } from '../../entities';
+import type { FabricValue } from './base';
+export type InferViewport<Fabric extends FabricValue> = Viewport;

package/__inner__/types/fabric/utils.d.ts

@@ -0,0 +1,2 @@
+import type { Breakpoints, Scope } from '../entities';
+export declare const createScope: <TBreakpoints extends Breakpoints>(breakpoints: TBreakpoints) => Scope<TBreakpoints>;

package/__inner__/types/hooks/index.d.ts

@@ -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__/types/hooks/useBreakpoint.d.ts

@@ -0,0 +1,2 @@
+import type { Breakpoints } from '../entities';
+export declare const useBreakpoint: <TBreakpoints extends Breakpoints>() => import("../entities").BreakpointState<TBreakpoints>;

package/__inner__/types/hooks/useBreakpointObserver.d.ts

@@ -0,0 +1,2 @@
+import type { BreakpointState, Breakpoints } from '../entities';
+export declare const useBreakpointObserver: <TBreakpoints extends Breakpoints>(onChange?: (current: BreakpointState<TBreakpoints>, previous: BreakpointState<TBreakpoints>) => void) => import("@ozen-ui/kit/useStoredValue").StoredValue<BreakpointState<TBreakpoints>>;

package/__inner__/types/hooks/useDeviceType.d.ts

@@ -0,0 +1,2 @@
+import type { TypeState, Breakpoints } from '../entities';
+export declare const useDeviceType: <TBreakpoints extends Breakpoints>() => TypeState;

package/__inner__/types/hooks/useDeviceTypeObserver.d.ts

@@ -0,0 +1,2 @@
+import type { TypeState, Breakpoints } from '../entities';
+export declare const useDeviceTypeObserver: <TBreakpoints extends Breakpoints>(onChange?: (current: TypeState, previous: TypeState) => void) => import("@ozen-ui/kit/useStoredValue").StoredValue<TypeState>;

package/__inner__/types/hooks/useOS.d.ts

@@ -0,0 +1,2 @@
+import type { OSState, Breakpoints } from '../entities';
+export declare const useOS: <TBreakpoints extends Breakpoints>() => OSState;

package/__inner__/types/hooks/useOSObserver.d.ts

@@ -0,0 +1,2 @@
+import type { OSState, Breakpoints } from '../entities';
+export declare const useOSObserver: <TBreakpoints extends Breakpoints>(onChange?: (current: OSState, previous: OSState) => void) => import("@ozen-ui/kit/useStoredValue").StoredValue<OSState>;

package/__inner__/types/hooks/useOrientation.d.ts

@@ -0,0 +1,2 @@
+import type { OrientationState, Breakpoints } from '../entities';
+export declare const useOrientation: <TBreakpoints extends Breakpoints>() => OrientationState;

package/__inner__/types/hooks/useOrientationObserver.d.ts

@@ -0,0 +1,2 @@
+import type { OrientationState, Breakpoints } from '../entities';
+export declare const useOrientationObserver: <TBreakpoints extends Breakpoints>(onChange?: (current: OrientationState, previous: OrientationState) => void) => import("@ozen-ui/kit/useStoredValue").StoredValue<OrientationState>;

package/__inner__/types/hooks/useSnapshot.d.ts

@@ -0,0 +1,2 @@
+import type { Breakpoints } from '../entities';
+export declare const useSnapshot: <TBreakpoints extends Breakpoints>() => import("../store/types").Snapshot<TBreakpoints>;

package/__inner__/types/hooks/useSnapshotObserver.d.ts

@@ -0,0 +1,3 @@
+import type { Breakpoints } from '../entities';
+import type { Snapshot } from '../store/types';
+export declare const useSnapshotObserver: <TBreakpoints extends Breakpoints>(onChange?: (current: Snapshot<TBreakpoints>, previous: Snapshot<TBreakpoints>) => void) => import("@ozen-ui/kit/useStoredValue").StoredValue<Snapshot<TBreakpoints>>;

package/__inner__/types/hooks/useViewport.d.ts

@@ -0,0 +1,2 @@
+import type { Breakpoints, Viewport } from '../entities';
+export declare const useViewport: <TBreakpoints extends Breakpoints>() => Viewport;

package/__inner__/types/hooks/useViewportObserver.d.ts

@@ -0,0 +1,2 @@
+import type { Breakpoints, Viewport } from '../entities';
+export declare const useViewportObserver: <TBreakpoints extends Breakpoints>(onChange?: (current: Viewport, previous: Viewport) => void) => import("@ozen-ui/kit/useStoredValue").StoredValue<Viewport>;

package/__inner__/types/index.d.ts

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

package/__inner__/types/provider/ResponsiveContext.d.ts

@@ -0,0 +1,8 @@
+import type { Breakpoints } from '../entities';
+import type { ResponsiveStore } from '../store';
+export type ResponsiveContextValue<TBreakpoints extends Breakpoints> = {
+    store: ResponsiveStore<TBreakpoints>;
+};
+export declare const AutocompleteBaseContextDefaultValue: ResponsiveContextValue<Breakpoints>;
+export declare const ResponsiveContext: import("react").Context<ResponsiveContextValue<Breakpoints>>;
+export declare const useResponsiveContext: <TBreakpoints extends Breakpoints>() => ResponsiveContextValue<TBreakpoints>;

package/__inner__/types/provider/ResponsiveProvider.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { Breakpoints } from '../entities';
+import type { ResponsiveProviderProps } from './types';
+export declare const ResponsiveProvider: <TBreakpoints extends Breakpoints>({ scope, children, }: ResponsiveProviderProps<TBreakpoints>) => React.JSX.Element;

package/__inner__/types/provider/index.d.ts

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

package/__inner__/types/provider/types.d.ts

@@ -0,0 +1,6 @@
+import type { ReactNode } from 'react';
+import type { Breakpoints, Scope } from '../entities';
+export type ResponsiveProviderProps<TBreakpoints extends Breakpoints> = {
+    scope: Scope<TBreakpoints>;
+    children: ReactNode;
+};

package/__inner__/types/store/ResponsiveStore.d.ts

@@ -0,0 +1,16 @@
+import { EventBus } from "@ozen-ui/kit/utils";
+import type { Breakpoints, Scope } from '../entities';
+import type { Events, Snapshot } from './types';
+export declare class ResponsiveStore<TBreakpoints extends Breakpoints> {
+    eventBus: EventBus<Events<TBreakpoints>>;
+    snapshot: Snapshot<TBreakpoints>;
+    scope: Scope<TBreakpoints>;
+    private raf;
+    private cleanup;
+    constructor(scope: Scope<TBreakpoints>);
+    getSnapshot(): Snapshot<TBreakpoints>;
+    mount(): void;
+    unmount(): void;
+    private notify;
+    private schedule;
+}

package/__inner__/types/store/index.d.ts

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

package/__inner__/types/store/types.d.ts

@@ -0,0 +1,12 @@
+import type { BreakpointState, OrientationState, OSState, TypeState, Breakpoints, Viewport } from '../entities';
+export type Snapshot<TBreakpoints extends Breakpoints> = {
+    orientation: OrientationState;
+    viewport: Viewport;
+    size: BreakpointState<TBreakpoints>;
+    type: TypeState;
+    os: OSState;
+};
+export type Events<TBreakpoints extends Breakpoints> = Record<'orientationChange' | 'viewportChange' | 'breakpointChange' | 'typeChange' | 'osChange' | 'snapshotChange', {
+    previous: Snapshot<TBreakpoints>;
+    current: Snapshot<TBreakpoints>;
+}>;

package/__inner__/types/store/utils.d.ts

@@ -0,0 +1,5 @@
+import type { OS, OSState, Breakpoints, Scope, Type, TypeState, OrientationState, BreakpointState, Viewport } from '../entities';
+export declare const getTypeState: <TBreakpoints extends Breakpoints>(scope: Scope<TBreakpoints>, current: Type) => TypeState;
+export declare const getOrientationState: ({ width, height, }: Viewport) => OrientationState;
+export declare const getBreakpointState: <TBreakpoints extends Breakpoints>(scope: Scope<TBreakpoints>, width: number) => BreakpointState<TBreakpoints>;
+export declare const getOSState: <TBreakpoints extends Breakpoints>(scope: Scope<TBreakpoints>, current: OS) => OSState;

package/__inner__/types/ui/ResponsiveNodes/ResponsiveNodes.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+import type { Breakpoints } from '../../entities';
+import type { ResponsiveNodesProps } from './types';
+export declare const ResponsiveNodes: <TBreakpoints extends Breakpoints>({ by, fallback, }: ResponsiveNodesProps<TBreakpoints>) => string | number | boolean | Iterable<React.ReactNode> | React.JSX.Element | null | undefined;

package/__inner__/types/ui/ResponsiveNodes/index.d.ts

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

package/__inner__/types/ui/ResponsiveNodes/types.d.ts

@@ -0,0 +1,6 @@
+import type { ReactNode } from 'react';
+import type { Breakpoints, ByBreakpoints } from '../../entities';
+export type ResponsiveNodesProps<TBreakpoints extends Breakpoints> = {
+    fallback?: () => ReactNode;
+    by: ByBreakpoints<TBreakpoints, ReactNode | (() => ReactNode)>;
+};

package/__inner__/types/ui/ResponsiveProps/ResponsiveProps.d.ts

@@ -0,0 +1,5 @@
+import type { ElementType } from 'react';
+import React from 'react';
+import type { Breakpoints } from '../../entities';
+import type { ResponsivePropsProps } from './types';
+export declare const ResponsiveProps: <TBreakpoints extends Breakpoints, Component extends ElementType>({ component, props, sharedProps: sharedPropsProp, fallback, }: ResponsivePropsProps<TBreakpoints, Component>) => React.JSX.Element;

package/__inner__/types/ui/ResponsiveProps/index.d.ts

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

package/__inner__/types/ui/ResponsiveProps/types.d.ts

@@ -0,0 +1,8 @@
+import type { ComponentProps, ElementType, ReactNode } from 'react';
+import type { Breakpoints, ByBreakpoints } from '../../entities';
+export type ResponsivePropsProps<TBreakpoints extends Breakpoints, Component extends ElementType> = {
+    fallback?: () => ReactNode;
+    component: Component;
+    props: ByBreakpoints<TBreakpoints, ComponentProps<Component> | (() => ComponentProps<Component>)>;
+    sharedProps?: Partial<ComponentProps<Component>> | (() => Partial<ComponentProps<Component>>);
+};