@koobiq/react-core 0.0.1-beta.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Koobiq
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1 @@
+# @koobiq/react-core

package/dist/hooks/index.d.ts

@@ -0,0 +1,13 @@
+export * from './usePrevious/index.js';
+export * from './useMultiRef/index.js';
+export * from './useIsomorphicEffect/index.js';
+export * from './useMediaQuery';
+export * from './useSsr/index.js';
+export * from './useDOMRef/index.js';
+export * from './useBoolean/index.js';
+export * from './useMutableRef/index.js';
+export * from './useInterval/index.js';
+export * from './useIsFirstRender/index.js';
+export * from './useEventListener/index.js';
+export * from './useResizeObserver/index.js';
+export * from './useElementSize/index.js';

package/dist/hooks/useBoolean/index.d.ts

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

package/dist/hooks/useBoolean/useBoolean.d.ts

@@ -0,0 +1,13 @@
+import type { Dispatch, SetStateAction } from 'react';
+export type UseBooleanControllers = {
+    /** Set the value to `true` */
+    on: () => void;
+    /** Set the value to `false` */
+    off: () => void;
+    /** Toggle the value to the opposite state */
+    toggle: () => void;
+    /** Set the value to a specific state */
+    set: Dispatch<SetStateAction<boolean>>;
+};
+export type UseBooleanReturnValue = [boolean, UseBooleanControllers];
+export declare function useBoolean(defaultValue?: boolean): UseBooleanReturnValue;

package/dist/hooks/useBoolean/useBoolean.js

@@ -0,0 +1,11 @@
+import { useState, useCallback } from "react";
+function useBoolean(defaultValue = false) {
+  const [value, setValue] = useState(defaultValue);
+  const on = useCallback(() => setValue(true), []);
+  const off = useCallback(() => setValue(false), []);
+  const toggle = useCallback(() => setValue((value2) => !value2), []);
+  return [value, { on, off, toggle, set: setValue }];
+}
+export {
+  useBoolean
+};

package/dist/hooks/useDOMRef/index.d.ts

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

package/dist/hooks/useDOMRef/useDOMRef.d.ts

@@ -0,0 +1,2 @@
+import type { Ref, RefObject } from 'react';
+export declare function useDOMRef<T extends HTMLElement = HTMLElement>(ref?: RefObject<T | null> | Ref<T | null>): RefObject<T>;

package/dist/hooks/useDOMRef/useDOMRef.js

@@ -0,0 +1,9 @@
+import { useRef, useImperativeHandle } from "react";
+function useDOMRef(ref) {
+  const domRef = useRef(null);
+  useImperativeHandle(ref, () => domRef.current);
+  return domRef;
+}
+export {
+  useDOMRef
+};

package/dist/hooks/useElementSize/index.d.ts

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

package/dist/hooks/useElementSize/useElementSize.d.ts

@@ -0,0 +1,5 @@
+export declare function useElementSize<T extends HTMLElement = any>(options?: ResizeObserverOptions): {
+    ref: import("react").RefObject<T>;
+    width: number;
+    height: number;
+};

package/dist/hooks/useElementSize/useElementSize.js

@@ -0,0 +1,9 @@
+"use client";
+import { useResizeObserver } from "../useResizeObserver/useResizeObserver.js";
+function useElementSize(options) {
+  const [ref, { width, height }] = useResizeObserver(options);
+  return { ref, width, height };
+}
+export {
+  useElementSize
+};

package/dist/hooks/useEventListener/index.d.ts

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

package/dist/hooks/useEventListener/useEventListener.d.ts

@@ -0,0 +1,19 @@
+import type { RefObject } from 'react';
+type UseEventListener<T, K, P> = {
+    /** Event name, for example, "click". */
+    eventName: T;
+    /** A handler function that runs as soon as the event happens. */
+    handler: K;
+    /** The element to which the event will be attached. */
+    element?: P;
+    /** An additional object with properties. */
+    options?: boolean | AddEventListenerOptions;
+    /** An indicator of event handler activity, used to improve performance. */
+    active?: boolean;
+};
+export declare function useEventListener<K extends keyof MediaQueryListEventMap>({ eventName, handler, element, options, active, }: UseEventListener<K, (event: MediaQueryListEventMap[K]) => void, RefObject<MediaQueryList>>): void;
+export declare function useEventListener<K extends keyof WindowEventMap>({ eventName, handler, element, options, active, }: UseEventListener<K, (event: WindowEventMap[K]) => void, undefined>): void;
+export declare function useEventListener<K extends keyof HTMLElementEventMap, T extends HTMLElement = HTMLDivElement>({ eventName, handler, element, options, active, }: UseEventListener<K, (event: HTMLElementEventMap[K]) => void, RefObject<T>>): void;
+export declare function useEventListener<K extends keyof DocumentEventMap>({ eventName, handler, element, options, active, }: UseEventListener<K, (event: DocumentEventMap[K]) => void, RefObject<Document>>): void;
+export declare function useEventListener({ eventName, handler, element, options, active, }: UseEventListener<string, (event: Event | CustomEvent) => void, RefObject<Document | HTMLElement | Window> | undefined>): void;
+export {};

package/dist/hooks/useEventListener/useEventListener.js

@@ -0,0 +1,32 @@
+"use client";
+import { useCallback, useEffect } from "react";
+import { useMutableRef } from "../useMutableRef/useMutableRef.js";
+function useEventListener({
+  eventName,
+  handler,
+  element,
+  options,
+  active = true
+}) {
+  const savedListener = useMutableRef(handler);
+  const handleEventListener = useCallback((event) => {
+    savedListener.current?.(event);
+  }, []);
+  useEffect(() => {
+    if (!active) {
+      return void 0;
+    }
+    const targetElement = element?.current ?? window;
+    targetElement?.addEventListener(eventName, handleEventListener, options);
+    return () => {
+      targetElement?.removeEventListener(
+        eventName,
+        handleEventListener,
+        options
+      );
+    };
+  }, [eventName, element, options, active]);
+}
+export {
+  useEventListener
+};

package/dist/hooks/useInterval/index.d.ts

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

package/dist/hooks/useInterval/useInterval.d.ts

@@ -0,0 +1,5 @@
+export declare function useInterval(
+/** A callback function that will be triggered at a given interval */
+callback: () => void, 
+/** Time interval in milliseconds */
+interval: number | null): void;

package/dist/hooks/useInterval/useInterval.js

@@ -0,0 +1,18 @@
+"use client";
+import { useEffect } from "react";
+import { useMutableRef } from "../useMutableRef/useMutableRef.js";
+function useInterval(callback, interval) {
+  const savedCallback = useMutableRef(callback);
+  useEffect(() => {
+    let intervalId;
+    if (interval || interval === 0) {
+      intervalId = setInterval(() => savedCallback.current(), interval);
+    }
+    return () => {
+      clearInterval(intervalId);
+    };
+  }, [interval]);
+}
+export {
+  useInterval
+};

package/dist/hooks/useIsFirstRender/index.d.ts

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

package/dist/hooks/useIsFirstRender/useIsFirstRender.d.ts

@@ -0,0 +1 @@
+export declare function useIsFirstRender(): boolean;

package/dist/hooks/useIsFirstRender/useIsFirstRender.js

@@ -0,0 +1,13 @@
+"use client";
+import { useRef } from "react";
+function useIsFirstRender() {
+  const renderRef = useRef(true);
+  if (renderRef.current) {
+    renderRef.current = false;
+    return true;
+  }
+  return renderRef.current;
+}
+export {
+  useIsFirstRender
+};

package/dist/hooks/useIsomorphicEffect/index.d.ts

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

package/dist/hooks/useIsomorphicEffect/useIsomorphicEffect.d.ts

@@ -0,0 +1,2 @@
+import { useEffect } from 'react';
+export declare const useIsomorphicEffect: typeof useEffect;

package/dist/hooks/useIsomorphicEffect/useIsomorphicEffect.js

@@ -0,0 +1,6 @@
+import { useLayoutEffect, useEffect } from "react";
+import { isBrowser } from "../../utils/isBrowser.js";
+const useIsomorphicEffect = isBrowser() ? useLayoutEffect : useEffect;
+export {
+  useIsomorphicEffect
+};

package/dist/hooks/useMediaQuery/index.d.ts

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

package/dist/hooks/useMediaQuery/useMediaQuery.d.ts

@@ -0,0 +1,15 @@
+export type UseMediaQueryOptions = {
+    /**
+     * As `window.matchMedia()` is unavailable on the server,
+     * it returns a default matches during the first mount.
+     * @default false
+     */
+    defaultMatches: boolean[];
+    /**
+     * The `defaultMatches` property is what will be returned
+     * on the first mount if ssr is set to `true`.
+     * @default true
+     */
+    ssr?: boolean;
+};
+export declare function useMediaQuery(query: string[], options?: UseMediaQueryOptions): boolean[];

package/dist/hooks/useMediaQuery/useMediaQuery.js

@@ -0,0 +1,43 @@
+"use client";
+import { useState, useEffect } from "react";
+function listen(query, callback) {
+  query.addEventListener("change", callback);
+  return () => query.removeEventListener("change", callback);
+}
+function useMediaQuery(query, options) {
+  const { defaultMatches, ssr = true } = options || {};
+  const queries = Array.isArray(query) ? query : [query];
+  const [value, setValue] = useState(
+    () => queries.map((query2, index) => ({
+      media: query2,
+      matches: !ssr ? window.matchMedia?.(query2)?.matches : defaultMatches?.[index] || false
+    }))
+  );
+  useEffect(() => {
+    setValue((prev) => {
+      const current = queries.map((query2) => ({
+        media: query2,
+        matches: window.matchMedia(query2).matches
+      }));
+      return prev.every(
+        (v, i) => v.matches === current[i].matches && v.media === current[i].media
+      ) ? prev : current;
+    });
+    const mql = queries.map((query2) => window.matchMedia(query2));
+    const handler = (evt) => {
+      setValue(
+        (prev) => prev.slice().map((item) => {
+          if (item.media === evt.media)
+            return { ...item, matches: evt.matches };
+          return item;
+        })
+      );
+    };
+    const cleanups = mql.map((mq) => listen(mq, handler));
+    return () => cleanups.forEach((fn) => fn());
+  }, []);
+  return value.map((item) => item.matches);
+}
+export {
+  useMediaQuery
+};

package/dist/hooks/useMultiRef/index.d.ts

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

package/dist/hooks/useMultiRef/useMultiRef.d.ts

@@ -0,0 +1,4 @@
+import type { Dispatch, SetStateAction, RefCallback, Ref as ReactRef } from 'react';
+type Ref<T> = ReactRef<T> | Dispatch<SetStateAction<T | undefined>> | null;
+export declare function useMultiRef<T>(refs: Array<Ref<T> | undefined>): RefCallback<T> | null;
+export {};

package/dist/hooks/useMultiRef/useMultiRef.js

@@ -0,0 +1,19 @@
+"use client";
+import { useRef, useMemo } from "react";
+import { setRef } from "../../utils/setRef.js";
+function useMultiRef(refs) {
+  const arrRefs = useRef(refs);
+  return useMemo(() => {
+    if (!arrRefs.current.length) {
+      return null;
+    }
+    return (node) => {
+      arrRefs.current.forEach((ref) => {
+        setRef(ref, node);
+      });
+    };
+  }, [arrRefs]);
+}
+export {
+  useMultiRef
+};

package/dist/hooks/useMutableRef/index.d.ts

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

package/dist/hooks/useMutableRef/useMutableRef.d.ts

@@ -0,0 +1 @@
+export declare function useMutableRef<T>(value: T): import("react").MutableRefObject<T>;

package/dist/hooks/useMutableRef/useMutableRef.js

@@ -0,0 +1,10 @@
+"use client";
+import { useRef } from "react";
+function useMutableRef(value) {
+  const ref = useRef(value);
+  ref.current = value;
+  return ref;
+}
+export {
+  useMutableRef
+};

package/dist/hooks/usePrevious/index.d.ts

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

package/dist/hooks/usePrevious/usePrevious.d.ts

@@ -0,0 +1 @@
+export declare function usePrevious<T>(value: T): T | null;

package/dist/hooks/usePrevious/usePrevious.js

@@ -0,0 +1,11 @@
+import { useRef, useEffect } from "react";
+function usePrevious(value) {
+  const ref = useRef(null);
+  useEffect(() => {
+    ref.current = value;
+  }, [value]);
+  return ref.current;
+}
+export {
+  usePrevious
+};

package/dist/hooks/useResizeObserver/index.d.ts

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

package/dist/hooks/useResizeObserver/useResizeObserver.d.ts

@@ -0,0 +1,3 @@
+type ObserverRect = Omit<DOMRectReadOnly, 'toJSON'>;
+export declare function useResizeObserver<T extends HTMLElement = any>(options?: ResizeObserverOptions): readonly [import("react").RefObject<T>, ObserverRect];
+export {};

package/dist/hooks/useResizeObserver/useResizeObserver.js

@@ -0,0 +1,49 @@
+"use client";
+import { useRef, useState, useMemo, useEffect } from "react";
+const defaultState = {
+  x: 0,
+  y: 0,
+  width: 0,
+  height: 0,
+  top: 0,
+  left: 0,
+  bottom: 0,
+  right: 0
+};
+function useResizeObserver(options) {
+  const frameID = useRef(0);
+  const ref = useRef(null);
+  const [rect, setRect] = useState(defaultState);
+  const observer = useMemo(
+    () => typeof window !== "undefined" && typeof ResizeObserver !== "undefined" ? (
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      new ResizeObserver((entries) => {
+        const entry = entries[0];
+        if (entry) {
+          cancelAnimationFrame(frameID.current);
+          frameID.current = requestAnimationFrame(() => {
+            if (ref.current) {
+              setRect(entry.contentRect);
+            }
+          });
+        }
+      })
+    ) : null,
+    []
+  );
+  useEffect(() => {
+    if (ref.current) {
+      observer?.observe(ref.current, options);
+    }
+    return () => {
+      observer?.disconnect();
+      if (frameID.current) {
+        cancelAnimationFrame(frameID.current);
+      }
+    };
+  }, [ref.current]);
+  return [ref, rect];
+}
+export {
+  useResizeObserver
+};

package/dist/hooks/useSsr/index.d.ts

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

package/dist/hooks/useSsr/useSsr.d.ts

@@ -0,0 +1,7 @@
+type SsrState = {
+    isBrowser: boolean;
+    isServer: boolean;
+};
+export type UseSsrReturn = SsrState;
+export declare const useSsr: () => UseSsrReturn;
+export {};

package/dist/hooks/useSsr/useSsr.js

@@ -0,0 +1,15 @@
+import { useState, useEffect } from "react";
+import { isBrowser } from "../../utils/isBrowser.js";
+const useSsr = () => {
+  const [browser, setBrowser] = useState(false);
+  useEffect(() => {
+    setBrowser(isBrowser());
+  }, []);
+  return {
+    isBrowser: browser,
+    isServer: !browser
+  };
+};
+export {
+  useSsr
+};

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+import { useFocusRing, FocusableProvider } from '@react-aria/focus';
+import { useHover, usePress } from '@react-aria/interactions';
+import { mergeProps, filterDOMProps } from '@react-aria/utils';
+import { useToggleState } from '@react-stately/toggle';
+export * from './types/index.js';
+export * from './styles/index.js';
+export * from './hooks/index.js';
+export * from './utils/index.js';
+export { FocusableProvider, mergeProps, useFocusRing, useHover, usePress, useToggleState, filterDOMProps, };

package/dist/index.js

@@ -0,0 +1,55 @@
+import { FocusableProvider, useFocusRing } from "@react-aria/focus";
+import { useHover, usePress } from "@react-aria/interactions";
+import { filterDOMProps, mergeProps } from "@react-aria/utils";
+import { useToggleState } from "@react-stately/toggle";
+import { clsx } from "./styles/clsx.js";
+import { usePrevious } from "./hooks/usePrevious/usePrevious.js";
+import { useMultiRef } from "./hooks/useMultiRef/useMultiRef.js";
+import { useIsomorphicEffect } from "./hooks/useIsomorphicEffect/useIsomorphicEffect.js";
+import { useMediaQuery } from "./hooks/useMediaQuery/useMediaQuery.js";
+import { useSsr } from "./hooks/useSsr/useSsr.js";
+import { useDOMRef } from "./hooks/useDOMRef/useDOMRef.js";
+import { useBoolean } from "./hooks/useBoolean/useBoolean.js";
+import { useMutableRef } from "./hooks/useMutableRef/useMutableRef.js";
+import { useInterval } from "./hooks/useInterval/useInterval.js";
+import { useIsFirstRender } from "./hooks/useIsFirstRender/useIsFirstRender.js";
+import { useEventListener } from "./hooks/useEventListener/useEventListener.js";
+import { useResizeObserver } from "./hooks/useResizeObserver/useResizeObserver.js";
+import { useElementSize } from "./hooks/useElementSize/useElementSize.js";
+import { polymorphicForwardRef } from "./utils/polymorphicForwardRef.js";
+import { isNotNil } from "./utils/typeGuards/isNotNil.js";
+import { isString } from "./utils/typeGuards/isString.js";
+import { isNumber } from "./utils/typeGuards/isNumber.js";
+import { setRef } from "./utils/setRef.js";
+import { isBrowser } from "./utils/isBrowser.js";
+import { capitalizeFirstLetter } from "./utils/capitalizeFirstLetter/capitalizeFirstLetter.js";
+export {
+  FocusableProvider,
+  capitalizeFirstLetter,
+  clsx,
+  filterDOMProps,
+  isBrowser,
+  isNotNil,
+  isNumber,
+  isString,
+  mergeProps,
+  polymorphicForwardRef,
+  setRef,
+  useBoolean,
+  useDOMRef,
+  useElementSize,
+  useEventListener,
+  useFocusRing,
+  useHover,
+  useInterval,
+  useIsFirstRender,
+  useIsomorphicEffect,
+  useMediaQuery,
+  useMultiRef,
+  useMutableRef,
+  usePress,
+  usePrevious,
+  useResizeObserver,
+  useSsr,
+  useToggleState
+};

package/dist/styles/clsx.d.ts

@@ -0,0 +1,3 @@
+type ClassName = string | false | null | undefined;
+export declare function clsx(...classNames: ClassName[]): string;
+export {};

package/dist/styles/clsx.js

@@ -0,0 +1,6 @@
+function clsx(...classNames) {
+  return classNames.filter((className) => Boolean(className)).join(" ");
+}
+export {
+  clsx
+};

package/dist/styles/index.d.ts

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

package/dist/types/DataAttributeProps.d.ts

@@ -0,0 +1,3 @@
+type DataAttributeKey = `data-${string}`;
+export type DataAttributeProps = Record<DataAttributeKey, unknown>;
+export {};

package/dist/types/DistributiveOmit.d.ts

@@ -0,0 +1 @@
+export type DistributiveOmit<T, K extends keyof any> = T extends any ? Omit<T, K> : never;

package/dist/types/ExtendableComponentPropsWithRef.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentPropsWithRef, ElementType } from 'react';
+import type { ExtendableProps } from './ExtendableProps.js';
+export type ExtendableComponentPropsWithRef<Props, Element extends ElementType> = ExtendableProps<Props, ComponentPropsWithRef<Element>>;

package/dist/types/ExtendableProps.d.ts

@@ -0,0 +1,2 @@
+import type { Merge } from './Merge';
+export type ExtendableProps<OverrideProps = Record<string, unknown>, ExtendedProps = Record<string, unknown>> = Merge<ExtendedProps, OverrideProps>;

package/dist/types/Merge.d.ts

@@ -0,0 +1,3 @@
+import type { DistributiveOmit } from './DistributiveOmit';
+export type Merge<A, B> = Omit<A, keyof B> & B;
+export type DistributiveMerge<A, B> = DistributiveOmit<A, keyof B> & B;

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from './Merge';
+export * from './DistributiveOmit';
+export * from './ExtendableProps.js';
+export * from './DataAttributeProps';
+export * from './ExtendableComponentPropsWithRef.js';

package/dist/utils/capitalizeFirstLetter/capitalizeFirstLetter.d.ts

@@ -0,0 +1,2 @@
+/** Capitalizes the first character of a word. */
+export declare function capitalizeFirstLetter(string: string): string;

package/dist/utils/capitalizeFirstLetter/capitalizeFirstLetter.js

@@ -0,0 +1,6 @@
+function capitalizeFirstLetter(string) {
+  return string.charAt(0).toUpperCase() + string.slice(1);
+}
+export {
+  capitalizeFirstLetter
+};

package/dist/utils/capitalizeFirstLetter/index.d.ts

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

package/dist/utils/index.d.ts

@@ -0,0 +1,5 @@
+export * from './polymorphicForwardRef';
+export * from './typeGuards/index.js';
+export * from './setRef.js';
+export * from './isBrowser.js';
+export * from './capitalizeFirstLetter';

package/dist/utils/isBrowser.d.ts

@@ -0,0 +1 @@
+export declare const isBrowser: () => boolean;

package/dist/utils/isBrowser.js

@@ -0,0 +1,6 @@
+const isBrowser = () => Boolean(
+  typeof window !== "undefined" && window.document && window.document.createElement
+);
+export {
+  isBrowser
+};

package/dist/utils/polymorphicForwardRef.d.ts

@@ -0,0 +1,13 @@
+import type { ElementType, ReactElement, ComponentPropsWithRef, ForwardRefRenderFunction, ForwardRefExoticComponent } from 'react';
+import type { DistributiveMerge, Merge } from '../types';
+export type AsProps<Component extends ElementType, PermanentProps extends object, ComponentProps extends object> = DistributiveMerge<ComponentProps, PermanentProps & {
+    as?: Component;
+}>;
+export type PolymorphicWithRef<Default extends OnlyAs, Props extends object = object, OnlyAs extends ElementType = ElementType> = <T extends OnlyAs = Default>(props: AsProps<T, Props, ComponentPropsWithRef<T>>) => ReactElement | null;
+export type PolyForwardComponent<Default extends OnlyAs, Props extends object = object, OnlyAs extends ElementType = ElementType> = Merge<ForwardRefExoticComponent<Merge<ComponentPropsWithRef<Default>, Props & {
+    as?: Default;
+}>>, PolymorphicWithRef<Default, Props, OnlyAs>>;
+export type PolyRefFunction = <Default extends OnlyAs, Props extends object = object, OnlyAs extends ElementType = ElementType>(Component: ForwardRefRenderFunction<any, Props & {
+    as?: OnlyAs;
+}>) => PolyForwardComponent<Default, Props, OnlyAs>;
+export declare const polymorphicForwardRef: PolyRefFunction;

package/dist/utils/polymorphicForwardRef.js

@@ -0,0 +1,5 @@
+import { forwardRef } from "react";
+const polymorphicForwardRef = forwardRef;
+export {
+  polymorphicForwardRef
+};

package/dist/utils/setRef.d.ts

@@ -0,0 +1,4 @@
+import type { Dispatch, SetStateAction, Ref as ReactRef } from 'react';
+type Ref<T> = ReactRef<T> | Dispatch<SetStateAction<T | undefined>> | null;
+export declare const setRef: <T>(ref: Ref<T> | undefined, value: T) => void;
+export {};

package/dist/utils/setRef.js

@@ -0,0 +1,10 @@
+const setRef = (ref, value) => {
+  if (typeof ref === "function") {
+    ref(value);
+  } else if (ref) {
+    ref.current = value;
+  }
+};
+export {
+  setRef
+};

package/dist/utils/typeGuards/index.d.ts

@@ -0,0 +1,3 @@
+export * from './isNotNil.js';
+export * from './isString.js';
+export * from './isNumber.js';

package/dist/utils/typeGuards/isNotNil.d.ts

@@ -0,0 +1 @@
+export declare const isNotNil: <T>(p: T) => p is Exclude<T, undefined | null>;

package/dist/utils/typeGuards/isNotNil.js

@@ -0,0 +1,4 @@
+const isNotNil = (p) => p !== void 0 && p !== null;
+export {
+  isNotNil
+};

package/dist/utils/typeGuards/isNumber.d.ts

@@ -0,0 +1 @@
+export declare const isNumber: (data: unknown) => data is number;

package/dist/utils/typeGuards/isNumber.js

@@ -0,0 +1,4 @@
+const isNumber = (data) => typeof data === "number";
+export {
+  isNumber
+};

package/dist/utils/typeGuards/isString.d.ts

@@ -0,0 +1 @@
+export declare const isString: (data: unknown) => data is string;

package/dist/utils/typeGuards/isString.js

@@ -0,0 +1,4 @@
+const isString = (data) => typeof data === "string";
+export {
+  isString
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@koobiq/react-core",
+  "version": "0.0.1-beta.1",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "dependencies": {
+    "@react-aria/focus": "^3.18.0",
+    "@react-aria/interactions": "^3.21.0",
+    "@react-aria/utils": "^3.25.0",
+    "@react-stately/toggle": "^3.7.0"
+  },
+  "peerDependencies": {
+    "react": "18.x || 19.x",
+    "react-dom": "18.x || 19.x"
+  },
+  "scripts": {
+    "clean": "rimraf dist && rimraf node_modules && rimraf .turbo",
+    "lint:js": "eslint --ext .ts,.tsx src --fix",
+    "lint": "pnpm lint:js",
+    "build": "vite build && tsc -p tsconfig.build.json && rm -rf dist/node_modules",
+    "type-check": "tsc --noEmit --pretty"
+  }
+}