@panneau/core 4.0.11 → 4.0.15

package/dist/hooks.d.ts

@@ -0,0 +1,362 @@
+import { Dayjs } from 'dayjs';
+import { ReactNode, SubmitEvent, RefObject } from 'react';
+
+interface UseAnimationFrameOptions {
+    disabled?: boolean;
+}
+declare function useAnimationFrame(onFrame: (progress: number) => void, { disabled }?: UseAnimationFrameOptions): void;
+
+interface UseFormattedDateOptions {
+    format?: Intl.DateTimeFormatOptions | null;
+    showToday?: boolean;
+}
+interface UseFormattedTimeOptions {
+    format?: Intl.DateTimeFormatOptions | null;
+    showNow?: boolean;
+    timeGap?: number;
+}
+declare function useFormattedDate({ format, showToday, }?: UseFormattedDateOptions): (date: string | Date | Dayjs) => string;
+declare function useFormattedTime({ format, showNow, timeGap, }?: UseFormattedTimeOptions): (date: string | Date | Dayjs) => string;
+
+declare const useDocumentEvent: (event: string, callback: (...args: unknown[]) => void, enabled?: boolean) => void;
+
+/**
+ * Form Types
+ * TypeScript interfaces for form-related components
+ */
+
+/**
+ * Field definition
+ */
+interface Field$1 {
+    name?: string;
+    type?: string;
+    component?: string;
+    label?: ReactNode;
+}
+
+/**
+ * Resource Types
+ * TypeScript interfaces for resources, items, users, media, and other entities
+ */
+
+interface ResourceIntlValues {
+    a_singular?: string;
+    a_plural?: string;
+    [key: string]: unknown;
+}
+/**
+ * Internationalization configuration
+ */
+interface ResourceIntl {
+    messages?: Record<string, string>;
+    values?: ResourceIntlValues;
+}
+/**
+ * Resource definition
+ */
+interface Resource {
+    id: string;
+    name: string;
+    intl?: ResourceIntl;
+    fields?: Field$1[];
+    forms?: Record<string, unknown>;
+    shows_in_navbar?: boolean;
+    settings?: Record<string, unknown>;
+}
+
+type FieldInput = string | Field$1;
+interface FieldErrors {
+    [key: string]: string[] | FieldErrors;
+}
+interface FieldValue {
+    [key: string]: unknown;
+}
+interface ProcessedField extends Field$1 {
+    name: string | null;
+    component: string | null;
+    value: unknown;
+    errors: string[] | null;
+    onChange: (fieldValue: unknown) => void;
+    fields?: ProcessedField[] | null;
+}
+interface RequestState {
+    success: boolean;
+    loading: boolean;
+    error: boolean;
+}
+interface UseFormOptions {
+    fields?: FieldInput[];
+    action?: string | null;
+    postForm?: ((action: string, data: Record<string, unknown>) => Promise<unknown>) | null;
+    initialErrors?: FieldErrors | null;
+    errors?: FieldErrors | null;
+    setErrors?: ((errors: FieldErrors | null) => void) | null;
+    initialGeneralError?: string | null;
+    generalError?: string | null;
+    setGeneralError?: ((error: string | null) => void) | null;
+    initialValue?: FieldValue | null;
+    value?: FieldValue | null;
+    setValue?: ((value: FieldValue) => void) | null;
+    withoutDefault?: boolean;
+    withoutPropagation?: boolean;
+    onComplete?: ((response: unknown) => void) | null;
+    onError?: ((error: Error) => void) | null;
+    locales?: string[];
+}
+interface UseFormReturn extends RequestState {
+    value: FieldValue | null;
+    setValue: (value: FieldValue) => void;
+    csrfToken: string | null;
+    submit: (submitValue?: FieldValue | null) => void;
+    onSubmit: (e: SubmitEvent) => void;
+    status: 'loading' | 'success' | 'error' | null;
+    response: unknown;
+    fields: ProcessedField[];
+    errors: FieldErrors | null;
+    generalError: string | null;
+}
+declare function useForm(opts?: UseFormOptions): UseFormReturn;
+
+interface UseIsVisibleOptions {
+    rootMargin?: string;
+    threshold?: number;
+    persist?: boolean;
+}
+interface UseIsVisibleResult {
+    ref: RefObject<HTMLElement>;
+    visible: boolean;
+}
+declare function useIsVisible({ rootMargin, threshold, persist, }?: UseIsVisibleOptions): UseIsVisibleResult;
+
+declare const KEYCODES: {
+    ARROW_LEFT: number;
+    ARROW_UP: number;
+    ARROW_RIGHT: number;
+    ARROW_DOWN: number;
+    ESCAPE: number;
+    SPACE: number;
+};
+interface UseKeyboardKeysOptions {
+    eventName?: string;
+}
+declare function useKeyboardKeys(keys?: Record<number, (e: KeyboardEvent) => void>, { eventName }?: UseKeyboardKeysOptions): void;
+
+interface FontConfig {
+    type?: 'google' | 'custom' | 'system';
+    name: string;
+}
+declare function useLoadedFonts(fonts: (string | FontConfig)[]): {
+    loaded: boolean;
+};
+
+interface UseMediaApiOptions {
+    url?: string | null;
+    initialMuted?: boolean;
+    onTimeUpdate?: ((time: number) => void) | null;
+    onProgressStep?: ((step: number) => void) | null;
+    onDurationChanged?: ((duration: number) => void) | null;
+    onVolumeChanged?: ((muted: boolean, volume: number) => void) | null;
+    onPlay?: ((opts: {
+        initial: boolean;
+    }) => void) | null;
+    onPause?: ((opts: {
+        midway: boolean;
+    }) => void) | null;
+    onEnded?: (() => void) | null;
+    onSeeked?: ((time: number) => void) | null;
+    onLoadStart?: (() => void) | null;
+    onCanPlayThough?: (() => void) | null;
+}
+interface UseMediaApiReturn {
+    ref: RefObject<HTMLMediaElement>;
+    play: () => void;
+    pause: () => void;
+    togglePlay: () => void;
+    stop: () => void;
+    seek: (time: number) => void;
+    mute: () => void;
+    unMute: () => void;
+    toggleMute: () => void;
+    muted: boolean;
+    currentTime: number | null;
+    duration: number | null;
+    playing: boolean;
+    paused: boolean;
+    ready: boolean;
+}
+declare function useMediaApi({ url, initialMuted, onTimeUpdate, onProgressStep, onDurationChanged, onVolumeChanged, onPlay, onPause, onEnded, onSeeked, onLoadStart, onCanPlayThough, }?: UseMediaApiOptions): UseMediaApiReturn;
+
+interface Manager {
+    getDefinition: (type: string) => Record<string, unknown> | null;
+}
+interface MediasParserOptions {
+    fieldsManager: Manager;
+    screensManager: Manager;
+}
+interface Media$1 {
+    id?: string | null;
+    [key: string]: unknown;
+}
+interface Field {
+    id?: string | null;
+    name?: string | null;
+    type?: string | null;
+    media?: boolean;
+    fields?: Field[];
+    itemsField?: Field | null;
+    settings?: Field[];
+    [key: string]: unknown;
+}
+interface Screen$1 {
+    type: string;
+    [key: string]: unknown;
+}
+interface Story {
+    theme?: Story | null;
+    components?: Screen$1[];
+    medias?: Record<string, Media$1> | null;
+    [key: string]: unknown;
+}
+declare class MediasParser {
+    fieldsManager: Manager;
+    screensManager: Manager;
+    constructor({ fieldsManager, screensManager }: MediasParserOptions);
+    toPath(story: Story | null): Story | null;
+    fromPath(story: Story | null, defaultMedias?: Record<string, Media$1> | null): Story | null;
+    getMediaFieldsPattern(fields: Field[], namePrefix?: string | null): RegExp[];
+    static fieldIsMedia({ media }: Field): boolean;
+    static fieldIsFontFamily({ id }: Field): boolean;
+    static replacePathsWithMedias(data: unknown, medias: Record<string, Media$1>, patterns: RegExp[], keyPrefix?: string | null): unknown;
+    static getMediaPath({ id }: Media$1): string | null;
+    static replaceMediasWithPaths(data: unknown, patterns: RegExp[], medias?: Record<string, Media$1> | null, keyPrefix?: string | null): {
+        data: unknown;
+        medias: Record<string, Media$1> | null;
+    };
+}
+
+interface UseMediasParserReturn {
+    toPath: (story: unknown) => string;
+    fromPath: (story: unknown) => unknown;
+    parser: MediasParser;
+}
+declare function useMediasParser(): UseMediasParserReturn;
+
+type ObserverConstructor<T> = (new (callback: (entries: T[]) => void, options?: Record<string, unknown>) => {
+    observe: (element: Element) => void;
+    unobserve?: (element: Element) => void;
+    disconnect: () => void;
+}) | null;
+interface ObserverWrapper<T> {
+    subscribe: (element: Element, callback: (entry: T) => void) => void;
+    unsubscribe: (element: Element, callback?: ((entry: T) => void) | null) => void;
+    observer: ReturnType<NonNullable<ObserverConstructor<T>>>;
+}
+interface ObserverOptions {
+    root?: Element | null;
+    rootMargin?: string | null;
+    threshold?: number | number[] | null;
+    disabled?: boolean;
+}
+declare function getObserver<T>(Observer: ObserverConstructor<T>, options?: ObserverOptions): ObserverWrapper<T>;
+interface UseObserverReturn<T> {
+    ref: RefObject<Element>;
+    entry: T;
+}
+declare function useObserver<T>(Observer: ObserverConstructor<T>, opts?: ObserverOptions, initialEntry?: T): UseObserverReturn<T>;
+interface IntersectionObserverEntry {
+    target: Element | null;
+    time: number | null;
+    isVisible: boolean;
+    isIntersecting: boolean;
+    intersectionRatio: number;
+    intersectionRect: DOMRectReadOnly | null;
+    boundingClientRect: DOMRectReadOnly | null;
+    rootBounds: DOMRectReadOnly | null;
+}
+interface UseIntersectionObserverOptions {
+    root?: Element | null;
+    rootMargin?: string;
+    threshold?: number | number[];
+    disabled?: boolean;
+}
+declare function useIntersectionObserver({ root, rootMargin, threshold, disabled, }?: UseIntersectionObserverOptions): UseObserverReturn<IntersectionObserverEntry>;
+/**
+ * Resize Observer
+ */
+interface ResizeObserverEntry {
+    target: Element | null;
+    contentRect: DOMRectReadOnly | null;
+    contentBoxSize: ReadonlyArray<ResizeObserverSize> | null;
+    borderBoxSize: ReadonlyArray<ResizeObserverSize> | null;
+}
+interface UseResizeObserverOptions {
+    disabled?: boolean;
+}
+declare function useResizeObserver({ disabled, }?: UseResizeObserverOptions): UseObserverReturn<ResizeObserverEntry>;
+
+interface ResourceType {
+    id?: string | null;
+    name?: string | null;
+}
+interface ResourceWithTypes extends Resource {
+    types?: ResourceType[];
+    settings?: {
+        hideTypeNames?: boolean;
+    };
+}
+declare function useResourceTypeName(resource: ResourceWithTypes | null, type?: string | null): string | null;
+
+type ResourceUrlGenerator = (routeResourceId: string | Resource, routeName?: string | Record<string, unknown> | null, params?: Record<string, unknown> | null) => string | null;
+declare function useResourceUrlGenerator(resourceId?: string | Resource | null): ResourceUrlGenerator;
+
+interface QueryParams {
+    page?: number;
+    count?: number;
+    [key: string]: unknown;
+}
+interface UseQueryReturn {
+    query: QueryParams | null;
+    onPageChange: (newPage: number) => void;
+    onQueryChange: (newQuery: QueryParams | null) => void;
+    onQueryReset: () => void;
+}
+declare function useQuery(initialBaseQuery?: QueryParams | null, paginated?: boolean): UseQueryReturn;
+
+interface Screen {
+    name: string;
+    mediaQuery?: string | null;
+}
+interface Media {
+    type: string;
+    width: string;
+    height: string;
+}
+interface UseScreenSizeOptions {
+    width?: number | null;
+    height?: number | null;
+    landscape?: boolean;
+    screens?: Screen[];
+    mediaType?: string;
+    media?: Media | null;
+}
+interface ScreenSize {
+    screen: string | null;
+    screens: string[];
+    width: number | null;
+    height: number | null;
+    landscape: boolean;
+}
+interface UseScreenSizeFromElementOptions extends Omit<UseScreenSizeOptions, 'landscape'> {
+    withoutMaxSize?: boolean;
+}
+interface UseScreenSizeFromElementReturn {
+    ref: RefObject<Element>;
+    screenSize: ScreenSize;
+}
+declare function useScreenSizeFromElement({ width, height, ...opts }?: UseScreenSizeFromElementOptions): UseScreenSizeFromElementReturn;
+declare function useScreenSizeFromWindow(opts?: UseScreenSizeOptions): ScreenSize;
+
+declare const useWindowEvent: (event: string, callback: (...args: unknown[]) => void, enabled?: boolean) => void;
+
+export { KEYCODES, getObserver, useAnimationFrame, useDocumentEvent, useForm, useFormattedDate, useFormattedTime, useIntersectionObserver, useIsVisible, useKeyboardKeys, useLoadedFonts, useMediaApi, useMediasParser, useObserver, useQuery, useResizeObserver, useResourceTypeName, useResourceUrlGenerator, useScreenSizeFromElement, useScreenSizeFromWindow, useWindowEvent };

package/{es → dist}/hooks.js

@@ -7,10 +7,10 @@ import _objectSpread from '@babel/runtime/helpers/objectSpread2';
 import _toConsumableArray from '@babel/runtime/helpers/toConsumableArray';
 import _objectWithoutProperties from '@babel/runtime/helpers/objectWithoutProperties';
 import { getCsrfToken, postJSON, getCSRFHeaders } from '@folklore/fetch';
-import get from 'lodash-es/get';
-import isArray from 'lodash-es/isArray';
-import isObject from 'lodash-es/isObject';
-import isString from 'lodash-es/isString';
+import get from 'lodash/get';
+import isArray from 'lodash/isArray';
+import isObject from 'lodash/isObject';
+import isString from 'lodash/isString';
 import { useFieldsManager, usePanneauResources, useResource, useUrlGenerator } from '@panneau/core/contexts';
 import dayjs from 'dayjs';
 import { useIntl } from 'react-intl';
@@ -42,7 +42,7 @@ function useAnimationFrame(onFrame) {
   }, [disabled]);
 }
 
-var useFormattedDate = function useFormattedDate() {
+function useFormattedDate() {
   var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
     _ref$format = _ref.format,
     format = _ref$format === void 0 ? null : _ref$format,
@@ -67,8 +67,8 @@ var useFormattedDate = function useFormattedDate() {
       day: '2-digit'
     }, format));
   }, [today, showToday, format]);
-};
-var useFormattedTime = function useFormattedTime() {
+}
+function useFormattedTime() {
   var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
     _ref2$format = _ref2.format,
     format = _ref2$format === void 0 ? null : _ref2$format,
@@ -94,14 +94,14 @@ var useFormattedTime = function useFormattedTime() {
       minute: 'numeric'
     }, format));
   }, [now, showNow, timeGap, format]);
-};
+}
 
 var eventsManager$1 = typeof document !== 'undefined' ? new EventsManager(document) : null;
 var useDocumentEvent = createUseEvent(eventsManager$1);
 
 var _excluded$1 = ["value", "errors", "onChange"];
 // prettier-ignore
-var _getFieldsPropsFromFields = function getFieldsPropsFromFields(fields, _ref) {
+function getFieldsPropsFromFields(fields, _ref) {
   var value = _ref.value,
     errors = _ref.errors,
     _onChange = _ref.onChange,
@@ -143,15 +143,15 @@ var _getFieldsPropsFromFields = function getFieldsPropsFromFields(fields, _ref)
       onChange: function onChange(fieldValue) {
         return _onChange(name, fieldValue);
       },
-      fields: fieldFields !== null && isArray(fieldFields) ? _getFieldsPropsFromFields(fieldFields, {
+      fields: fieldFields !== null && isArray(fieldFields) ? getFieldsPropsFromFields(fieldFields, {
         value: value !== null && name !== null && isObject(value[name]) ? value[name] : null,
         errors: subfieldErrors,
         onChange: _onChange
       }, locales) : null
     }, props)]);
   }, []);
-};
-var useForm = function useForm() {
+}
+function useForm() {
   var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   var _opts$fields = opts.fields,
     fields = _opts$fields === void 0 ? [] : _opts$fields,
@@ -242,7 +242,7 @@ var useForm = function useForm() {
     setValue(_objectSpread(_objectSpread({}, value || {}), {}, _defineProperty({}, fieldName, fieldValue)));
   }, [value, errors, requestState, setErrors, setValue].concat(_toConsumableArray(fields)));
   var fieldsProps = useMemo(function () {
-    return _getFieldsPropsFromFields(fields, {
+    return getFieldsPropsFromFields(fields, {
       value: value,
       errors: errors,
       onChange: onFieldChange
@@ -331,21 +331,21 @@ var useForm = function useForm() {
     errors: errors,
     generalError: generalError
   });
-};
+}
 
-var buildThresholdArray = function buildThresholdArray() {
+function buildThresholdArray() {
   return [0, 1.0];
-};
+}
 var observersCache = new Map();
-var getOptionsKey = function getOptionsKey(_ref) {
+function getOptionsKey(_ref) {
   var _ref$root = _ref.root,
     root = _ref$root === void 0 ? null : _ref$root,
     rootMargin = _ref.rootMargin,
     _ref$threshold = _ref.threshold,
     threshold = _ref$threshold === void 0 ? null : _ref$threshold;
   return "root_".concat(root, "_rootMargin_").concat(rootMargin || null, "_threshold_").concat(threshold);
-};
-var createObserver = function createObserver(Observer) {
+}
+function createObserver(Observer) {
   var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   var subscribers = [];
   var addSubscriber = function addSubscriber(element, callback) {
@@ -422,8 +422,8 @@ var createObserver = function createObserver(Observer) {
     unsubscribe: unsubscribe,
     observer: observer
   };
-};
-var getObserver = function getObserver(Observer) {
+}
+function getObserver(Observer) {
   var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   if (Observer === null) {
     throw new Error('Observer constructor is null');
@@ -438,8 +438,8 @@ var getObserver = function getObserver(Observer) {
     observersCache.set(Observer, observers);
   }
   return observers[observerKey];
-};
-var useObserver = function useObserver(Observer) {
+}
+function useObserver(Observer) {
   var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
   var initialEntry = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   var _opts$root = opts.root,
@@ -491,7 +491,7 @@ var useObserver = function useObserver(Observer) {
     ref: nodeRef,
     entry: entry
   };
-};
+}
 
 /**
  * Intersection Observer
@@ -507,7 +507,7 @@ var intersectionObserverInitialEntry = {
   boundingClientRect: null,
   rootBounds: null
 };
-var useIntersectionObserver = function useIntersectionObserver() {
+function useIntersectionObserver() {
   var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
     _ref3$root = _ref3.root,
     root = _ref3$root === void 0 ? null : _ref3$root,
@@ -523,7 +523,7 @@ var useIntersectionObserver = function useIntersectionObserver() {
     threshold: threshold,
     disabled: disabled
   }, intersectionObserverInitialEntry);
-};
+}
 
 /**
  * Resize Observer
@@ -535,14 +535,14 @@ var resizeObserverInitialEntry = {
   contentBoxSize: null,
   borderBoxSize: null
 };
-var useResizeObserver = function useResizeObserver() {
+function useResizeObserver() {
   var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
     _ref4$disabled = _ref4.disabled,
     disabled = _ref4$disabled === void 0 ? false : _ref4$disabled;
   return useObserver(typeof window !== 'undefined' ? ResizeObserver : null, {
     disabled: disabled
   }, resizeObserverInitialEntry);
-};
+}
 
 function useIsVisible() {
   var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
@@ -603,30 +603,30 @@ var fontsMap = {
   loading: [],
   active: []
 };
-var isFontLoading = function isFontLoading(name) {
+function isFontLoading(name) {
   return fontsMap.loading.indexOf(name) !== -1;
-};
-var isFontActive = function isFontActive(name) {
+}
+function isFontActive(name) {
   return fontsMap.active.indexOf(name) !== -1;
-};
-var addFontLoading = function addFontLoading(name) {
+}
+function addFontLoading(name) {
   fontsMap.active = fontsMap.active.filter(function (it) {
     return it !== name;
   });
   fontsMap.loading = [].concat(_toConsumableArray(fontsMap.loading), [name]);
-};
-var removeFontLoading = function removeFontLoading(name) {
+}
+function removeFontLoading(name) {
   fontsMap.loading = fontsMap.loading.filter(function (it) {
     return it !== name;
   });
-};
-var addFontActive = function addFontActive(name) {
+}
+function addFontActive(name) {
   fontsMap.loading = fontsMap.loading.filter(function (it) {
     return it !== name;
   });
   fontsMap.active = [].concat(_toConsumableArray(fontsMap.active), [name]);
-};
-var useLoadedFonts = function useLoadedFonts(fonts) {
+}
+function useLoadedFonts(fonts) {
   var _useState = useState(false),
     _useState2 = _slicedToArray(_useState, 2),
     loaded = _useState2[0],
@@ -675,10 +675,10 @@ var useLoadedFonts = function useLoadedFonts(fonts) {
   return {
     loaded: loaded
   };
-};
+}
 
 var progressSteps = [0.1, 0.25, 0.5, 0.75, 0.9];
-var useMediaApi = function useMediaApi() {
+function useMediaApi() {
   var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
     _ref$url = _ref.url,
     url = _ref$url === void 0 ? null : _ref$url,
@@ -910,9 +910,9 @@ var useMediaApi = function useMediaApi() {
     paused: paused,
     ready: ready
   };
-};
+}
 
-var useMediasParser = function useMediasParser() {
+function useMediasParser() {
   // const screensManager = useScreensManager();
   var fieldsManager = useFieldsManager();
 
@@ -934,9 +934,9 @@ var useMediasParser = function useMediasParser() {
     fromPath: fromPath,
     parser: parser
   };
-};
+}
 
-var useResourceTypeName = function useResourceTypeName(resource) {
+function useResourceTypeName(resource) {
   var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
   var typeName = useMemo(function () {
     var _ref = resource || {},
@@ -962,14 +962,14 @@ var useResourceTypeName = function useResourceTypeName(resource) {
     return name === resourceName ? null : name;
   }, [type, resource]);
   return typeName;
-};
+}
 
-var getResource = function getResource(resources, resourceId) {
+function getResource(resources, resourceId) {
   return resourceId !== null && !isObject(resourceId) ? resources.find(function (it) {
     return it.id === resourceId;
   }) || null : resourceId;
-};
-var useResourceUrlGenerator = function useResourceUrlGenerator() {
+}
+function useResourceUrlGenerator() {
   var resourceId = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
   var resources = usePanneauResources();
   var contextResource = useResource();
@@ -989,9 +989,9 @@ var useResourceUrlGenerator = function useResourceUrlGenerator() {
     })) : null;
     return finalRoute;
   };
-};
+}
 
-var useQuery = function useQuery() {
+function useQuery() {
   var initialBaseQuery = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
   var paginated = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
   var initialQuery = useMemo(function () {
@@ -1028,11 +1028,11 @@ var useQuery = function useQuery() {
     onQueryChange: onQueryChange,
     onQueryReset: onQueryReset
   };
-};
+}
 
 var _excluded = ["width", "height"],
   _excluded2 = ["withoutMaxSize"];
-var useScreenSize = function useScreenSize(_ref) {
+function useScreenSize(_ref) {
   var _ref$width = _ref.width,
     width = _ref$width === void 0 ? null : _ref$width,
     _ref$height = _ref.height,
@@ -1072,8 +1072,8 @@ var useScreenSize = function useScreenSize(_ref) {
     height: height,
     landscape: landscape
   };
-};
-var useScreenSizeFromElement = function useScreenSizeFromElement() {
+}
+function useScreenSizeFromElement() {
   var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
     _ref4$width = _ref4.width,
     width = _ref4$width === void 0 ? null : _ref4$width,
@@ -1111,14 +1111,14 @@ var useScreenSizeFromElement = function useScreenSizeFromElement() {
     ref: ref,
     screenSize: screenSize
   };
-};
-var getWindowSize = function getWindowSize() {
+}
+function getWindowSize() {
   return {
     width: typeof window !== 'undefined' ? window.innerWidth : null,
     height: typeof window !== 'undefined' ? window.innerHeight : null
   };
-};
-var useScreenSizeFromWindow = function useScreenSizeFromWindow() {
+}
+function useScreenSizeFromWindow() {
   var opts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
   var _useState = useState(getWindowSize()),
     _useState2 = _slicedToArray(_useState, 2),
@@ -1138,7 +1138,7 @@ var useScreenSizeFromWindow = function useScreenSizeFromWindow() {
     };
   }, [setWindowSize]);
   return useScreenSize(_objectSpread(_objectSpread({}, opts), windowSize));
-};
+}
 
 var eventsManager = typeof window !== 'undefined' ? new EventsManager(window) : null;
 var useWindowEvent = createUseEvent(eventsManager);