@tarsis/toolkit 0.7.4 → 0.7.6

package/dist/components/unsorted/ShapeSelection/ShapeSelection.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+type Props = {
+    children: ReactNode;
+};
+export declare const ShapeSelection: ({ children }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/unsorted/SlideIn/SlideIn.d.ts

@@ -0,0 +1,18 @@
+import { ReactNode } from 'react';
+export declare enum SlideDirection {
+    TOP = "top",
+    TOP_LEFT = "top-left",
+    TOP_RIGHT = "top-right",
+    BOTTOM = "bottom",
+    BOTTOM_LEFT = "bottom-left",
+    BOTTOM_RIGHT = "bottom-right",
+    LEFT = "left",
+    RIGHT = "right"
+}
+type Props = {
+    direction: SlideDirection;
+    delay?: number;
+    children: ReactNode;
+};
+export declare const SlideIn: ({ children, direction, delay }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/unsorted/SmokeTextDisappearance/SmokeTextDisappearance.d.ts

@@ -0,0 +1,5 @@
+type Props = {
+    children: string;
+};
+export declare const SmokeTextDisappearance: ({ children }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/unsorted/SmoothScroll/SmoothScroll.d.ts

@@ -0,0 +1 @@
+export declare const SmoothScroll: () => import("react/jsx-runtime").JSX.Element;

package/dist/components/unsorted/SolarEclipse/BaileysBead.d.ts

@@ -0,0 +1,15 @@
+interface BaileysBeadProps {
+    theta: number;
+    offset?: number;
+    opa: number;
+}
+/**
+ * The Baily's beads effect or diamond ring effect is a feature of total and annular solar eclipses.
+ * As the Moon covers the Sun during a solar eclipse, the rugged topography of the lunar limb allows
+ * beads of sunlight to shine through in some places while not in others.
+ * The effect is named after Francis Baily, who explained the phenomenon in 1836.
+ *
+ * (Source: Wikipedia)
+ */
+export declare const BaileysBead: ({ theta, offset, opa }: BaileysBeadProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/unsorted/SolarEclipse/SolarEclipse.d.ts

@@ -0,0 +1 @@
+export declare const SolarEclipse: () => import("react/jsx-runtime").JSX.Element;

package/dist/components/unsorted/SolarEclipse/SolarEclipse.helpers.d.ts

@@ -0,0 +1,12 @@
+interface Coordinate {
+    x: number;
+    y: number;
+}
+export declare function normalize(value: number, min: number, max: number): number;
+export declare function calculateDistance(coordinates1: Coordinate, coordinates2: Coordinate): number;
+export declare function calculateAngle(coordinates1: Coordinate, coordinates2: Coordinate): number;
+export declare function getGlowLayers(factor: number, intensity: number): {
+    radius: number;
+    opacity: number;
+}[];
+export {};

package/dist/components/unsorted/SpeechToText/SpeechToText.d.ts

@@ -0,0 +1,22 @@
+declare global {
+    interface Window {
+        webkitSpeechRecognition: new () => {
+            continuous: boolean;
+            interimResults: boolean;
+            lang: string;
+            start(): void;
+            stop(): void;
+            onresult: ((event: SpeechRecognitionEvent) => void) | null;
+            onerror: ((event: SpeechRecognitionErrorEvent) => void) | null;
+        };
+    }
+}
+interface SpeechRecognitionEvent extends Event {
+    results: SpeechRecognitionResultList;
+}
+interface SpeechRecognitionErrorEvent extends Event {
+    error: string;
+    message: string;
+}
+export declare const SpeechToText: () => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/unsorted/StaticSolarEclipse/StaticSolarEclipse.d.ts

@@ -0,0 +1 @@
+export declare const StaticSolarEclipse: () => import("react/jsx-runtime").JSX.Element;

package/dist/components/unsorted/StickyList/StickyList.d.ts

@@ -0,0 +1 @@
+export declare const StickyList: () => import("react/jsx-runtime").JSX.Element;

package/dist/components/unsorted/TextImageHover/TextImageHover.d.ts

@@ -0,0 +1 @@
+export declare const TextImageHover: () => import("react/jsx-runtime").JSX.Element;

package/dist/components/unsorted/ThanosDisappearEffect/ThanosDisappearEffect.d.ts

@@ -0,0 +1,6 @@
+declare global {
+    interface HTMLElement {
+        disintegrated?: boolean;
+    }
+}
+export declare const ThanosDisappearEffect: () => import("react/jsx-runtime").JSX.Element;

package/dist/components/unsorted/ThanosDisappearEffectList/ThanosDisappearEffectList.d.ts

@@ -0,0 +1 @@
+export declare const ThanosDisappearEffectList: () => import("react/jsx-runtime").JSX.Element;

package/dist/components/unsorted/ThanosDissolve/ThanosDissolve.d.ts

@@ -0,0 +1,9 @@
+type Props = {
+    images?: string[];
+    duration?: number;
+    maxScale?: number;
+    className?: string;
+    onDelete?: VoidFunction;
+};
+export declare const ThanosDissolve: ({ images, duration, maxScale, className, onDelete, }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/unsorted/TranslucentBackdrop/TranslucentBackdrop.d.ts

@@ -0,0 +1 @@
+export declare const TranslucentBackdrop: () => import("react/jsx-runtime").JSX.Element;

package/dist/components/unsorted/TurbulenceFilter/TurbulenceFilter.d.ts

@@ -0,0 +1 @@
+export declare const TurbulenceFilter: () => import("react/jsx-runtime").JSX.Element | null;

package/dist/components/unsorted/ViewTransitionAddToCard/ViewTransitionAddToCard.d.ts

@@ -0,0 +1 @@
+export declare const ViewTransitionAddToCard: () => import("react/jsx-runtime").JSX.Element;

package/dist/components/unsorted/ViewTransitionImageGallery/ViewTransitionImageGallery.d.ts

@@ -0,0 +1 @@
+export declare const ViewTransitionImageGallery: () => import("react/jsx-runtime").JSX.Element;

package/dist/components/unsorted/VoiceAnimation/VoiceAnimation.d.ts

@@ -0,0 +1 @@
+export declare const VoiceAnimation: () => import("react/jsx-runtime").JSX.Element;

package/dist/{gl-CyEFDXce.cjs → gl-DEE7rq9M.cjs}

@@ -1,15 +1,15 @@
 const require_chunk = require("./chunk-CKQMccvm.cjs");
 const require_assets = require("./assets-BMqH4phf.cjs");
 let three = require("three");
-three = require_chunk.__toESM(three);
+three = require_chunk.__toESM(three, 1);
 let load_bmfont = require("load-bmfont");
-load_bmfont = require_chunk.__toESM(load_bmfont);
+load_bmfont = require_chunk.__toESM(load_bmfont, 1);
 let three_bmfont_text = require("three-bmfont-text");
-three_bmfont_text = require_chunk.__toESM(three_bmfont_text);
+three_bmfont_text = require_chunk.__toESM(three_bmfont_text, 1);
 let three_bmfont_text_shaders_msdf = require("three-bmfont-text/shaders/msdf");
-three_bmfont_text_shaders_msdf = require_chunk.__toESM(three_bmfont_text_shaders_msdf);
+three_bmfont_text_shaders_msdf = require_chunk.__toESM(three_bmfont_text_shaders_msdf, 1);
 let three_orbit_controls = require("three-orbit-controls");
-three_orbit_controls = require_chunk.__toESM(three_orbit_controls);
+three_orbit_controls = require_chunk.__toESM(three_orbit_controls, 1);
 //#region src/components/Loaders/EndlessLoader/shaders.ts
 var vertexShader = `
   varying vec2 vUv;

package/dist/global.d.ts

@@ -0,0 +1,87 @@
+declare module '*.css' {
+  const src: string
+  export default src
+}
+
+declare module '*.module.css' {
+  const classes: { [key: string]: string }
+  export default classes
+}
+
+declare module '*.module.scss' {
+  const classes: { [key: string]: string }
+  export default classes
+}
+
+declare module '*.svg' {
+  const src: string
+  export default src
+}
+
+declare module '*.png' {
+  const src: string
+  export default src
+}
+
+declare module '*.wav' {
+  const src: string
+  export default src
+}
+
+declare module '*.mp3' {
+  const src: string
+  export default src
+}
+
+declare module '*.ogg' {
+  const src: string
+  export default src
+}
+
+declare module '*.fnt' {
+  const src: string
+  export default src
+}
+
+declare module '*?url' {
+  const src: string
+  export default src
+}
+
+declare module 'three-orbit-controls' {
+  const value: any
+  export default value
+}
+
+declare module 'load-bmfont' {
+  const value: any
+  export default value
+}
+
+declare module 'three-bmfont-text' {
+  const value: any
+  export default value
+}
+
+declare module 'three-bmfont-text/shaders/msdf' {
+  const value: any
+  export default value
+}
+
+declare module 'swiper/css'
+
+declare module 'p5' {
+  interface P5Instance {
+    [key: string]: any
+  }
+  type p5 = P5Instance
+  const p5: {
+    new (
+      sketch: (p: P5Instance) => void,
+      node?: HTMLElement | null,
+    ): {
+      remove: VoidFunction
+    }
+  }
+  export default p5
+}

package/dist/hooks/index.d.ts

@@ -0,0 +1,20 @@
+/// <reference path="../global.d.ts" />
+export * from './useAnimatedText';
+export * from './useControllableState';
+export * from './useMergeRefs';
+export * from './useBowser';
+export * from './useDebounce';
+export * from './useEffectEvent';
+export * from './useInterval';
+export * from './useLiveRef';
+export * from './useMatchMedia';
+export * from './useOklch';
+export * from './useOutsideClick';
+export * from './usePrevious';
+export * from './useRaf';
+export * from './useThrottle';
+export * from './useTimeout';
+export * from './useWindowReady';
+export * from './useReducedMotion';
+export * from './useGsapContext';
+export * from './useFormField';

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

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

package/dist/hooks/useAnimatedText/useAnimatedText.d.ts

@@ -0,0 +1 @@
+export declare function useAnimatedText(text: string, delimiter?: 'letter' | 'word'): string;

package/dist/hooks/useBowser.d.ts

@@ -0,0 +1,11 @@
+interface UseBowserResult {
+    isMobile: boolean;
+    isDesktop: boolean;
+    isMacOS: boolean;
+    isIOS: boolean;
+    isSafari: boolean;
+    isFirefox: boolean;
+    isChrome: boolean;
+}
+export declare const useBowser: () => UseBowserResult | null;
+export {};

package/dist/hooks/useControllableState.d.ts

@@ -0,0 +1,2 @@
+declare function useControllableState<T>(controlledValue: T | undefined, defaultValue: T, onChange?: (value: T) => void): [T, (next: T | ((prev: T) => T)) => void];
+export { useControllableState };

package/dist/hooks/useDebounce.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Custom hook that debounces a callback function to delay its execution until after
+ * a specified wait time has elapsed since the last time it was invoked.
+ *
+ * Debouncing ensures that the callback is only executed once after a series of rapid calls,
+ * waiting for a pause in the calls before executing.
+ *
+ * @param callback - The function to debounce
+ * @param delay - The delay time (in milliseconds) to wait before executing the callback
+ * @param options - Optional configuration object
+ * @param options.maxWait - Maximum time before function must be invoked
+ * @param options.leading - If true, invoke on the leading edge
+ * @returns A debounced version of the callback function with a `cancel` method
+ *
+ * @example
+ * ```tsx
+ * const debouncedSearch = useDebounce((query: string) => {
+ *   console.log('Searching for:', query)
+ * }, 300)
+ *
+ * return <input onChange={(e) => debouncedSearch(e.target.value)} />
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // With maxWait and leading options
+ * const debouncedSearch = useDebounce(
+ *   (query: string) => console.log('Searching for:', query),
+ *   300,
+ *   { maxWait: 1000, leading: true }
+ * )
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Cancel pending debounced call
+ * const debouncedSearch = useDebounce((query: string) => {
+ *   console.log('Searching for:', query)
+ * }, 300)
+ *
+ * debouncedSearch('test')
+ * debouncedSearch.cancel() // Cancels the pending call
+ * ```
+ */
+export declare const useDebounce: <T extends (...args: any[]) => any>(callback: T, delay: number, { maxWait, leading }?: {
+    maxWait?: number;
+    leading?: boolean;
+}) => T & {
+    cancel: VoidFunction;
+};

package/dist/hooks/useEffectEvent.d.ts

@@ -0,0 +1,16 @@
+import React from 'react';
+/**
+ * Universal layout effect that uses useLayoutEffect in browser environments
+ * and falls back to useEffect in SSR environments
+ */
+export declare const useUniversalLayoutEffect: typeof React.useEffect;
+/**
+ * A React hook that implements the useEffectEvent pattern from React RFC.
+ * This hook allows you to define an event handler that can access the latest props/state
+ * without triggering effect dependency lists when the handler changes.
+ * @see https://github.com/reactjs/rfcs/blob/useevent/text/0000-useevent.md#internal-implementation
+ * @react https://react.dev/learn/separating-events-from-effects
+ */
+export declare function useEffectEvent<TArgs extends any[], TReturn extends undefined>(callback: undefined): (...args: TArgs) => TReturn;
+export declare function useEffectEvent<TArgs extends any[], TReturn>(callback: (...args: TArgs) => TReturn): (...args: TArgs) => TReturn;
+export declare function useEffectEvent<TArgs extends any[], TReturn>(callback: ((...args: TArgs) => TReturn) | undefined): (...args: TArgs) => TReturn | undefined;

package/dist/hooks/useFormField.d.ts

@@ -0,0 +1,36 @@
+type FormFieldIds = {
+    fieldId: string;
+    labelId: string;
+    errorId: string;
+    hintId: string;
+    descriptionId: string;
+};
+type FormFieldAria = {
+    'aria-describedby'?: string;
+    'aria-invalid'?: boolean;
+    'aria-errormessage'?: string;
+    id: string;
+};
+type UseFormFieldOptions = {
+    id?: string;
+    hasError?: boolean;
+    hasHint?: boolean;
+};
+type UseFormFieldReturn = {
+    ids: FormFieldIds;
+    labelProps: {
+        htmlFor: string;
+        id: string;
+    };
+    fieldProps: FormFieldAria;
+    errorProps: {
+        id: string;
+        role: 'alert';
+    };
+    hintProps: {
+        id: string;
+    };
+};
+declare function useFormField(options?: UseFormFieldOptions): UseFormFieldReturn;
+export { useFormField };
+export type { UseFormFieldReturn, UseFormFieldOptions, FormFieldIds };

package/dist/hooks/useGsapContext.d.ts

@@ -0,0 +1,20 @@
+import { type RefObject } from 'react';
+type GsapCallable = (...args: unknown[]) => unknown;
+type GsapContextLike = {
+    add(methodName: string, func: GsapCallable, scope?: Element | string | object): GsapCallable;
+    add<T extends GsapCallable>(func: T, scope?: Element | string | object): ReturnType<T>;
+    ignore(func: GsapCallable): void;
+    kill(revert?: boolean): void;
+    revert(config?: object): void;
+    clear(): void;
+    isReverted: boolean;
+};
+type GsapCleanup = () => void;
+/**
+ * Creates a GSAP context scoped to the given ref.
+ * All animations created inside the callback are automatically
+ * reverted on unmount — preventing DOM leak bugs.
+ */
+declare function useGsapContext(scope: RefObject<HTMLElement | null>, callback: (ctx: GsapContextLike) => void | GsapCleanup, deps?: unknown[]): RefObject<GsapContextLike | null>;
+export { useGsapContext };
+export type { GsapContextLike };

package/dist/hooks/useInterval.d.ts

@@ -0,0 +1,25 @@
+import { DependencyList } from 'react';
+/**
+ * Custom hook that manages an interval with automatic cleanup.
+ * Provides a reliable way to handle intervals that are properly cleaned up
+ * on component unmount or when dependencies change.
+ *
+ * @param callback - The function to execute on each interval
+ * @param delay - The delay in milliseconds (null to clear the interval)
+ * @param deps - Optional dependency array. If provided, interval restarts when deps change.
+ *               If not provided, callback updates via ref without restarting interval.
+ *
+ * @example
+ * ```tsx
+ * // Runs continuously, callback updates via ref
+ * useInterval(() => {
+ *   console.log('This runs every second')
+ * }, 1000)
+ *
+ * // Restarts interval when count changes
+ * useInterval(() => {
+ *   console.log('Count:', count)
+ * }, 1000, [count])
+ * ```
+ */
+export declare const useInterval: (callback: VoidFunction, delay?: number | null, deps?: DependencyList) => void;

package/dist/hooks/useLiveRef.d.ts

@@ -0,0 +1 @@
+export declare const useLiveRef: <T>(value: T) => import("react").RefObject<T>;

package/dist/hooks/useMatchMedia.d.ts

@@ -0,0 +1 @@
+export declare const useMatchMedia: (query: string) => boolean | null;

package/dist/hooks/useMergeRefs.d.ts

@@ -0,0 +1,5 @@
+import { type Ref, type RefCallback } from 'react';
+type PossibleRef<T> = Ref<T> | undefined | null;
+export declare function mergeRefs<T>(...refs: PossibleRef<T>[]): RefCallback<T>;
+export declare function useMergeRefs<T>(...refs: PossibleRef<T>[]): RefCallback<T>;
+export {};

package/dist/hooks/useOklch.d.ts

@@ -0,0 +1 @@
+export declare const useOklch: () => void;

package/dist/hooks/useOutsideClick.d.ts

@@ -0,0 +1,22 @@
+import { RefObject } from 'react';
+/**
+ * Custom hook that detects clicks outside of a specified element and triggers a callback.
+ *
+ * Useful for implementing dropdown menus, modals, or any component that should close
+ * when the user clicks outside of it.
+ *
+ * @param ref - React ref object pointing to the element to monitor
+ * @param callback - Function to call when a click occurs outside the element
+ * @param isActive - Whether the outside click detection should be active (default: true)
+ *
+ * @example
+ * ```tsx
+ * const ref = useRef<HTMLDivElement>(null)
+ * const [isOpen, setIsOpen] = useState(false)
+ *
+ * useOutsideClick(ref, () => setIsOpen(false), isOpen)
+ *
+ * return <div ref={ref}>...</div>
+ * ```
+ */
+export declare const useOutsideClick: <T extends HTMLElement = HTMLElement>(ref: RefObject<T | null>, callback: VoidFunction, isActive?: boolean) => void;

package/dist/hooks/usePrevious.d.ts

@@ -0,0 +1,2 @@
+export declare const usePreviousState: <T>(value: T) => T | undefined;
+export declare const usePreviousRender: <T>(value: T) => T | undefined;

package/dist/hooks/useRaf.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Custom hook that provides a requestAnimationFrame-based callback execution.
+ * Useful for performance-critical animations and continuous updates that should
+ * be synchronized with the browser's refresh rate.
+ *
+ * The callback will be executed on the next animation frame, and can be
+ * controlled with an enabled flag for conditional execution.
+ *
+ * @param callback - The function to execute on each animation frame
+ * @param enabled - Whether the animation loop should be active (default: true)
+ * @returns A function to manually trigger the animation frame callback
+ *
+ * @example
+ * ```tsx
+ * const animate = useRaf(() => {
+ *   // Animation logic here
+ *   console.log('Animation frame')
+ * }, isAnimating)
+ *
+ * // Manually trigger
+ * animate()
+ * ```
+ */
+export declare const useRaf: (callback: VoidFunction, enabled?: boolean) => VoidFunction;

package/dist/hooks/useReducedMotion.d.ts

@@ -0,0 +1,2 @@
+declare function useReducedMotion(): boolean;
+export { useReducedMotion };

package/dist/hooks/useThrottle.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Custom hook that throttles a callback function to limit how often it can be invoked.
+ *
+ * Throttling ensures that the callback is executed at most once per specified time interval,
+ * regardless of how many times the throttled function is called.
+ *
+ * @param callback - The function to throttle
+ * @param delay - The minimum time interval (in milliseconds) between executions
+ * @returns A throttled version of the callback function
+ *
+ * @example
+ * ```tsx
+ * const throttledClick = useThrottle(() => {
+ *   console.log('Button clicked')
+ * }, 500)
+ *
+ * return <button onClick={throttledClick}>Click me</button>
+ * ```
+ */
+export declare const useThrottle: <T extends (...args: any[]) => any>(callback: T, delay: number) => T;

package/dist/hooks/useTimeout.d.ts

@@ -0,0 +1,25 @@
+import { DependencyList } from 'react';
+/**
+ * Custom hook that manages a timeout with automatic cleanup.
+ * Provides a reliable way to handle timeouts that are properly cleaned up
+ * on component unmount or when dependencies change.
+ *
+ * @param callback - The function to execute after the delay
+ * @param delay - The delay in milliseconds (null to clear the timeout)
+ * @param deps - Optional dependency array. If provided, timeout restarts when deps change.
+ *               If not provided, callback updates via ref without restarting timeout.
+ *
+ * @example
+ * ```tsx
+ * // Runs once, callback updates via ref
+ * useTimeout(() => {
+ *   console.log('This runs after 1 second')
+ * }, 1000)
+ *
+ * // Restarts timeout when count changes
+ * useTimeout(() => {
+ *   console.log('Count:', count)
+ * }, 1000, [count])
+ * ```
+ */
+export declare const useTimeout: (callback: VoidFunction, delay?: number | null, deps?: DependencyList) => void;

package/dist/hooks/useWindowReady.d.ts

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

package/dist/hooks.cjs

@@ -2,12 +2,12 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const require_chunk = require("./chunk-CKQMccvm.cjs");
 const require_useMergeRefs = require("./useMergeRefs-C_l6omwU.cjs");
 let react = require("react");
-react = require_chunk.__toESM(react);
+react = require_chunk.__toESM(react, 1);
 let gsap = require("gsap");
-gsap = require_chunk.__toESM(gsap);
+gsap = require_chunk.__toESM(gsap, 1);
 let motion_react = require("motion/react");
 let bowser = require("bowser");
-bowser = require_chunk.__toESM(bowser);
+bowser = require_chunk.__toESM(bowser, 1);
 //#region src/hooks/usePrevious.ts
 var usePreviousState = (value) => {
 	const previousRef = (0, react.useRef)(void 0);