fromsrc 0.0.0 → 0.0.2

package/dist/hooks/queue.d.ts

@@ -0,0 +1,11 @@
+interface QueueResult<T> {
+    items: T[];
+    size: number;
+    enqueue: (item: T) => void;
+    dequeue: () => T | undefined;
+    peek: () => T | undefined;
+    clear: () => void;
+}
+declare function useQueue<T>(initial?: T[]): QueueResult<T>;
+
+export { type QueueResult, useQueue };

package/dist/hooks/queue.js

@@ -0,0 +1,23 @@
+"use client";
+import { useState, useCallback } from 'react';
+
+function useQueue(initial = []) {
+  const [items, setItems] = useState(initial);
+  const enqueue = useCallback((item) => {
+    setItems((prev) => [...prev, item]);
+  }, []);
+  const dequeue = useCallback(() => {
+    let removed;
+    setItems((prev) => {
+      if (prev.length === 0) return prev;
+      removed = prev[0];
+      return prev.slice(1);
+    });
+    return removed;
+  }, []);
+  const peek = useCallback(() => items[0], [items]);
+  const clear = useCallback(() => setItems([]), []);
+  return { items, size: items.length, enqueue, dequeue, peek, clear };
+}
+
+export { useQueue };

package/dist/hooks/readprogress.d.ts

@@ -0,0 +1,6 @@
+interface ReadProgressOptions {
+    containerRef?: React.RefObject<HTMLElement | null>;
+}
+declare function useReadProgress(options?: ReadProgressOptions): number;
+
+export { type ReadProgressOptions, useReadProgress };

package/dist/hooks/readprogress.js

@@ -0,0 +1,32 @@
+"use client";
+import { useState, useRef, useCallback, useEffect } from 'react';
+
+function useReadProgress(options) {
+  const [progress, setProgress] = useState(0);
+  const rafRef = useRef(0);
+  const handleScroll = useCallback(() => {
+    if (rafRef.current) return;
+    rafRef.current = requestAnimationFrame(() => {
+      const container = options?.containerRef?.current;
+      const element = container || document.documentElement;
+      const scrollTop = container ? container.scrollTop : element.scrollTop;
+      const scrollHeight = element.scrollHeight - (container ? container.clientHeight : window.innerHeight);
+      const newProgress = scrollHeight > 0 ? scrollTop / scrollHeight * 100 : 0;
+      const clamped = Math.min(100, Math.max(0, newProgress));
+      setProgress(clamped);
+      rafRef.current = 0;
+    });
+  }, [options?.containerRef]);
+  useEffect(() => {
+    const target = options?.containerRef?.current || window;
+    handleScroll();
+    target.addEventListener("scroll", handleScroll, { passive: true });
+    return () => {
+      target.removeEventListener("scroll", handleScroll);
+      if (rafRef.current) cancelAnimationFrame(rafRef.current);
+    };
+  }, [handleScroll, options?.containerRef]);
+  return progress;
+}
+
+export { useReadProgress };

package/dist/hooks/resizeobserver.d.ts

@@ -0,0 +1,10 @@
+interface ElementSize {
+    width: number;
+    height: number;
+}
+declare function useResizeObserver<T extends HTMLElement>(): [
+    React.RefObject<T | null>,
+    ElementSize
+];
+
+export { type ElementSize, useResizeObserver };

package/dist/hooks/resizeobserver.js

@@ -0,0 +1,25 @@
+"use client";
+import { useRef, useState, useEffect } from 'react';
+
+function useResizeObserver() {
+  const ref = useRef(null);
+  const [size, setSize] = useState({ width: 0, height: 0 });
+  useEffect(() => {
+    const el = ref.current;
+    if (!el) return;
+    const observer = new ResizeObserver((entries) => {
+      const entry = entries[0];
+      if (entry) {
+        setSize({
+          width: entry.contentRect.width,
+          height: entry.contentRect.height
+        });
+      }
+    });
+    observer.observe(el);
+    return () => observer.disconnect();
+  }, []);
+  return [ref, size];
+}
+
+export { useResizeObserver };

package/dist/hooks/script.d.ts

@@ -0,0 +1,4 @@
+type ScriptStatus = "idle" | "loading" | "ready" | "error";
+declare function useScript(src: string | null): ScriptStatus;
+
+export { type ScriptStatus, useScript };

package/dist/hooks/script.js

@@ -0,0 +1,30 @@
+"use client";
+import { useState, useEffect } from 'react';
+
+function useScript(src) {
+  const [status, setStatus] = useState(src ? "loading" : "idle");
+  useEffect(() => {
+    if (!src) {
+      setStatus("idle");
+      return;
+    }
+    const existing = document.querySelector(`script[src="${src}"]`);
+    if (existing) {
+      setStatus("ready");
+      return;
+    }
+    const script = document.createElement("script");
+    script.src = src;
+    script.async = true;
+    script.onload = () => setStatus("ready");
+    script.onerror = () => setStatus("error");
+    document.body.appendChild(script);
+    setStatus("loading");
+    return () => {
+      document.body.removeChild(script);
+    };
+  }, [src]);
+  return status;
+}
+
+export { useScript };

package/dist/hooks/scrolldirection.d.ts

@@ -0,0 +1,4 @@
+type ScrollDirection = "up" | "down" | null;
+declare function useScrollDirection(threshold?: number): ScrollDirection;
+
+export { type ScrollDirection, useScrollDirection };

package/dist/hooks/scrolldirection.js

@@ -0,0 +1,33 @@
+"use client";
+import { useState, useRef, useEffect } from 'react';
+
+function useScrollDirection(threshold = 10) {
+  const [direction, setDirection] = useState(null);
+  const last = useRef(0);
+  const ticking = useRef(false);
+  useEffect(() => {
+    last.current = window.scrollY;
+    const update = () => {
+      const current = window.scrollY;
+      const diff = current - last.current;
+      if (Math.abs(diff) >= threshold) {
+        setDirection(diff > 0 ? "down" : "up");
+        last.current = current;
+      }
+      ticking.current = false;
+    };
+    const handle = () => {
+      if (!ticking.current) {
+        ticking.current = true;
+        requestAnimationFrame(update);
+      }
+    };
+    window.addEventListener("scroll", handle, { passive: true });
+    return () => {
+      window.removeEventListener("scroll", handle);
+    };
+  }, [threshold]);
+  return direction;
+}
+
+export { useScrollDirection };

package/dist/hooks/scrolllock.d.ts

@@ -0,0 +1,3 @@
+declare function useScrollLock(locked: boolean): void;
+
+export { useScrollLock };

package/dist/hooks/scrolllock.js

@@ -0,0 +1,38 @@
+"use client";
+import { useEffect } from 'react';
+
+const countkey = "data-fromsrc-scroll-count";
+const savekey = "data-fromsrc-scroll-value";
+function getcount() {
+  return Number(document.body.getAttribute(countkey) ?? "0");
+}
+function setcount(value) {
+  document.body.setAttribute(countkey, String(value));
+}
+function lock() {
+  const count = getcount();
+  if (count === 0) {
+    document.body.setAttribute(savekey, document.body.style.overflow);
+    document.body.style.overflow = "hidden";
+  }
+  setcount(count + 1);
+}
+function unlock() {
+  const count = getcount();
+  if (count === 0) return;
+  const next = count - 1;
+  setcount(next);
+  if (next === 0) {
+    document.body.style.overflow = document.body.getAttribute(savekey) ?? "";
+    document.body.removeAttribute(savekey);
+  }
+}
+function useScrollLock(locked) {
+  useEffect(() => {
+    if (!locked) return;
+    lock();
+    return () => unlock();
+  }, [locked]);
+}
+
+export { useScrollLock };

package/dist/hooks/scrollspy.d.ts

@@ -0,0 +1,7 @@
+interface ScrollSpyOptions {
+    offset?: number;
+    threshold?: number;
+}
+declare function useScrollSpy(ids: string[], options?: ScrollSpyOptions): string | null;
+
+export { type ScrollSpyOptions, useScrollSpy };

package/dist/hooks/scrollspy.js

@@ -0,0 +1,28 @@
+"use client";
+import { useState, useEffect } from 'react';
+
+function useScrollSpy(ids, options = {}) {
+  const { offset = 100, threshold = 0.5 } = options;
+  const [activeId, setActiveId] = useState(null);
+  useEffect(() => {
+    const elements = ids.map((id) => document.getElementById(id)).filter((el) => el !== null);
+    if (elements.length === 0) return;
+    function handleScroll() {
+      const scrollTop = window.scrollY + offset;
+      const viewport = window.innerHeight * threshold;
+      let currentId = null;
+      for (const el of elements) {
+        if (el.offsetTop <= scrollTop + viewport) {
+          currentId = el.id;
+        }
+      }
+      setActiveId(currentId);
+    }
+    handleScroll();
+    window.addEventListener("scroll", handleScroll, { passive: true });
+    return () => window.removeEventListener("scroll", handleScroll);
+  }, [ids, offset, threshold]);
+  return activeId;
+}
+
+export { useScrollSpy };

package/dist/hooks/scrolltop.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Tracks whether the user is at the top of the page
+ * @returns true when scroll position is less than 10px from the top
+ */
+declare function useIsScrollTop(): boolean;
+
+export { useIsScrollTop };

package/dist/hooks/scrolltop.js

@@ -0,0 +1,19 @@
+"use client";
+import { useState, useEffect } from 'react';
+
+function useIsScrollTop() {
+  const [atTop, setAtTop] = useState(true);
+  useEffect(() => {
+    const handle = () => {
+      setAtTop(window.scrollY < 10);
+    };
+    handle();
+    window.addEventListener("scroll", handle, { passive: true });
+    return () => {
+      window.removeEventListener("scroll", handle);
+    };
+  }, []);
+  return atTop;
+}
+
+export { useIsScrollTop };

package/dist/hooks/selection.d.ts

@@ -0,0 +1,12 @@
+interface SelectionResult<T> {
+    selected: Set<T>;
+    toggle: (item: T) => void;
+    select: (item: T) => void;
+    deselect: (item: T) => void;
+    clear: () => void;
+    selectAll: (items: T[]) => void;
+    isSelected: (item: T) => boolean;
+}
+declare function useSelection<T>(initial?: T[]): SelectionResult<T>;
+
+export { type SelectionResult, useSelection };

package/dist/hooks/selection.js

@@ -0,0 +1,32 @@
+"use client";
+import { useState, useCallback } from 'react';
+
+function useSelection(initial = []) {
+  const [selected, setSelected] = useState(() => new Set(initial));
+  const toggle = useCallback((item) => {
+    setSelected((prev) => {
+      const next = new Set(prev);
+      if (next.has(item)) next.delete(item);
+      else next.add(item);
+      return next;
+    });
+  }, []);
+  const select = useCallback((item) => {
+    setSelected((prev) => new Set(prev).add(item));
+  }, []);
+  const deselect = useCallback((item) => {
+    setSelected((prev) => {
+      const next = new Set(prev);
+      next.delete(item);
+      return next;
+    });
+  }, []);
+  const clear = useCallback(() => setSelected(/* @__PURE__ */ new Set()), []);
+  const selectAll = useCallback((items) => {
+    setSelected(new Set(items));
+  }, []);
+  const isSelected = useCallback((item) => selected.has(item), [selected]);
+  return { selected, toggle, select, deselect, clear, selectAll, isSelected };
+}
+
+export { useSelection };

package/dist/hooks/share.d.ts

@@ -0,0 +1,13 @@
+interface ShareData {
+    title?: string;
+    text?: string;
+    url?: string;
+}
+interface ShareResult {
+    shared: boolean;
+    share: (data: ShareData) => void;
+    canShare: boolean;
+}
+declare function useShare(duration?: number): ShareResult;
+
+export { type ShareData, type ShareResult, useShare };

package/dist/hooks/share.js

@@ -0,0 +1,37 @@
+"use client";
+import { useState, useRef, useEffect, useCallback } from 'react';
+
+function useShare(duration = 1500) {
+  const [shared, setShared] = useState(false);
+  const [canShare] = useState(() => typeof navigator !== "undefined" && !!navigator.share);
+  const timeoutRef = useRef(null);
+  useEffect(() => {
+    return () => {
+      if (timeoutRef.current) clearTimeout(timeoutRef.current);
+    };
+  }, []);
+  const share = useCallback(
+    async (data) => {
+      try {
+        if (canShare && navigator.share) {
+          await navigator.share(data);
+          setShared(true);
+          if (timeoutRef.current) clearTimeout(timeoutRef.current);
+          timeoutRef.current = setTimeout(() => setShared(false), duration);
+        } else {
+          const fallback = data.url || data.text || "";
+          await navigator.clipboard.writeText(fallback);
+          setShared(true);
+          if (timeoutRef.current) clearTimeout(timeoutRef.current);
+          timeoutRef.current = setTimeout(() => setShared(false), duration);
+        }
+      } catch {
+        setShared(false);
+      }
+    },
+    [canShare, duration]
+  );
+  return { shared, share, canShare };
+}
+
+export { useShare };

package/dist/hooks/speechrecognition.d.ts

@@ -0,0 +1,10 @@
+interface SpeechResult {
+    text: string;
+    listening: boolean;
+    supported: boolean;
+    start: () => void;
+    stop: () => void;
+}
+declare function useSpeechRecognition(lang?: string): SpeechResult;
+
+export { type SpeechResult, useSpeechRecognition };

package/dist/hooks/speechrecognition.js

@@ -0,0 +1,34 @@
+"use client";
+import { useState, useRef, useCallback } from 'react';
+
+function useSpeechRecognition(lang = "en-US") {
+  const [text, setText] = useState("");
+  const [listening, setListening] = useState(false);
+  const supported = typeof window !== "undefined" && ("SpeechRecognition" in window || "webkitSpeechRecognition" in window);
+  const recognitionRef = useRef(null);
+  const start = useCallback(() => {
+    if (!supported) return;
+    const win = window;
+    const SR = win.SpeechRecognition || win.webkitSpeechRecognition;
+    if (!SR) return;
+    const recognition = new SR();
+    recognition.lang = lang;
+    recognition.continuous = true;
+    recognition.interimResults = true;
+    recognition.onresult = (e) => {
+      const transcript = Array.from(e.results).map((result) => result[0].transcript).join("");
+      setText(transcript);
+    };
+    recognition.onend = () => setListening(false);
+    recognitionRef.current = recognition;
+    recognition.start();
+    setListening(true);
+  }, [supported, lang]);
+  const stop = useCallback(() => {
+    recognitionRef.current?.stop();
+    setListening(false);
+  }, []);
+  return { text, listening, supported, start, stop };
+}
+
+export { useSpeechRecognition };

package/dist/hooks/stepper.d.ts

@@ -0,0 +1,13 @@
+interface StepperResult {
+    step: number;
+    total: number;
+    first: boolean;
+    last: boolean;
+    next: () => void;
+    prev: () => void;
+    goTo: (step: number) => void;
+    reset: () => void;
+}
+declare function useStepper(total: number, initial?: number): StepperResult;
+
+export { type StepperResult, useStepper };

package/dist/hooks/stepper.js

@@ -0,0 +1,31 @@
+"use client";
+import { useState, useCallback } from 'react';
+
+function useStepper(total, initial = 0) {
+  const [step, setStep] = useState(initial);
+  const next = useCallback(() => {
+    setStep((s) => Math.min(s + 1, total - 1));
+  }, [total]);
+  const prev = useCallback(() => {
+    setStep((s) => Math.max(s - 1, 0));
+  }, []);
+  const goTo = useCallback(
+    (s) => {
+      setStep(Math.max(0, Math.min(s, total - 1)));
+    },
+    [total]
+  );
+  const reset = useCallback(() => setStep(initial), [initial]);
+  return {
+    step,
+    total,
+    first: step === 0,
+    last: step === total - 1,
+    next,
+    prev,
+    goTo,
+    reset
+  };
+}
+
+export { useStepper };

package/dist/hooks/storage.d.ts

@@ -0,0 +1,5 @@
+type StorageSetter<T> = (value: T | ((prev: T) => T)) => void;
+declare function useLocalStorage<T>(key: string, defaultValue: T): [T, StorageSetter<T>];
+declare function useSessionStorage<T>(key: string, defaultValue: T): [T, StorageSetter<T>];
+
+export { useLocalStorage, useSessionStorage };

package/dist/hooks/storage.js

@@ -0,0 +1,57 @@
+"use client";
+import { useState, useEffect, useCallback } from 'react';
+
+const local = () => localStorage;
+const session = () => sessionStorage;
+function issamekind(value, sample) {
+  if (sample === null) return value === null;
+  if (Array.isArray(sample)) return Array.isArray(value);
+  const kind = typeof sample;
+  if (kind === "object") {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  return typeof value === kind;
+}
+function parsestored(raw, fallback) {
+  try {
+    const parsed = JSON.parse(raw);
+    return issamekind(parsed, fallback) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function useStorage(getStorage, key, defaultValue) {
+  const [value, setValue] = useState(defaultValue);
+  useEffect(() => {
+    try {
+      const stored = getStorage().getItem(key);
+      if (stored !== null) {
+        const parsed = parsestored(stored, defaultValue);
+        if (parsed !== null) setValue(parsed);
+      }
+    } catch {
+    }
+  }, [defaultValue, getStorage, key]);
+  const setStoredValue = useCallback(
+    (newValue) => {
+      setValue((prev) => {
+        const resolved = newValue instanceof Function ? newValue(prev) : newValue;
+        try {
+          getStorage().setItem(key, JSON.stringify(resolved));
+        } catch {
+        }
+        return resolved;
+      });
+    },
+    [getStorage, key]
+  );
+  return [value, setStoredValue];
+}
+function useLocalStorage(key, defaultValue) {
+  return useStorage(local, key, defaultValue);
+}
+function useSessionStorage(key, defaultValue) {
+  return useStorage(session, key, defaultValue);
+}
+
+export { useLocalStorage, useSessionStorage };

package/dist/hooks/stylesheet.d.ts

@@ -0,0 +1,4 @@
+type StylesheetStatus = "idle" | "loading" | "ready" | "error";
+declare function useStylesheet(href: string | null): StylesheetStatus;
+
+export { type StylesheetStatus, useStylesheet };

package/dist/hooks/stylesheet.js

@@ -0,0 +1,30 @@
+"use client";
+import { useState, useEffect } from 'react';
+
+function useStylesheet(href) {
+  const [status, setStatus] = useState(href ? "loading" : "idle");
+  useEffect(() => {
+    if (!href) {
+      setStatus("idle");
+      return;
+    }
+    const existing = document.querySelector(`link[href="${href}"]`);
+    if (existing) {
+      setStatus("ready");
+      return;
+    }
+    const link = document.createElement("link");
+    link.rel = "stylesheet";
+    link.href = href;
+    link.onload = () => setStatus("ready");
+    link.onerror = () => setStatus("error");
+    document.head.appendChild(link);
+    setStatus("loading");
+    return () => {
+      document.head.removeChild(link);
+    };
+  }, [href]);
+  return status;
+}
+
+export { useStylesheet };

package/dist/hooks/textselection.d.ts

@@ -0,0 +1,7 @@
+interface TextSelection {
+    text: string;
+    rect: DOMRect | null;
+}
+declare function useTextSelection(): TextSelection;
+
+export { type TextSelection, useTextSelection };

package/dist/hooks/textselection.js

@@ -0,0 +1,24 @@
+"use client";
+import { useState, useEffect } from 'react';
+
+function useTextSelection() {
+  const [selection, setSelection] = useState({ text: "", rect: null });
+  useEffect(() => {
+    function handler() {
+      const sel = window.getSelection();
+      const text = sel?.toString() ?? "";
+      if (!text) {
+        setSelection({ text: "", rect: null });
+        return;
+      }
+      const range = sel?.getRangeAt(0);
+      const rect = range?.getBoundingClientRect() ?? null;
+      setSelection({ text, rect });
+    }
+    document.addEventListener("selectionchange", handler);
+    return () => document.removeEventListener("selectionchange", handler);
+  }, []);
+  return selection;
+}
+
+export { useTextSelection };

package/dist/hooks/throttle.d.ts

@@ -0,0 +1,3 @@
+declare function useThrottle<T>(value: T, ms: number): T;
+
+export { useThrottle };

package/dist/hooks/throttle.js

@@ -0,0 +1,28 @@
+"use client";
+import { useState, useRef, useEffect } from 'react';
+
+function useThrottle(value, ms) {
+  const [throttled, setThrottled] = useState(value);
+  const lastRef = useRef(Date.now());
+  const timerRef = useRef(null);
+  useEffect(() => {
+    const now = Date.now();
+    const elapsed = now - lastRef.current;
+    if (elapsed >= ms) {
+      lastRef.current = now;
+      setThrottled(value);
+    } else {
+      if (timerRef.current) clearTimeout(timerRef.current);
+      timerRef.current = setTimeout(() => {
+        lastRef.current = Date.now();
+        setThrottled(value);
+      }, ms - elapsed);
+    }
+    return () => {
+      if (timerRef.current) clearTimeout(timerRef.current);
+    };
+  }, [value, ms]);
+  return throttled;
+}
+
+export { useThrottle };