fromsrc 0.0.0 → 0.0.2

package/dist/hooks/keypress.js

@@ -0,0 +1,23 @@
+"use client";
+import { useState, useEffect } from 'react';
+
+function useKeyPress(targetKey) {
+  const [pressed, setPressed] = useState(false);
+  useEffect(() => {
+    function down(e) {
+      if (e.key === targetKey) setPressed(true);
+    }
+    function up(e) {
+      if (e.key === targetKey) setPressed(false);
+    }
+    window.addEventListener("keydown", down);
+    window.addEventListener("keyup", up);
+    return () => {
+      window.removeEventListener("keydown", down);
+      window.removeEventListener("keyup", up);
+    };
+  }, [targetKey]);
+  return pressed;
+}
+
+export { useKeyPress };

package/dist/hooks/list.d.ts

@@ -0,0 +1,14 @@
+interface ListResult<T> {
+    items: T[];
+    set: (items: T[]) => void;
+    push: (item: T) => void;
+    removeAt: (index: number) => void;
+    updateAt: (index: number, item: T) => void;
+    insertAt: (index: number, item: T) => void;
+    clear: () => void;
+    filter: (fn: (item: T) => boolean) => void;
+    sort: (fn: (a: T, b: T) => number) => void;
+}
+declare function useList<T>(initial?: T[]): ListResult<T>;
+
+export { type ListResult, useList };

package/dist/hooks/list.js

@@ -0,0 +1,28 @@
+"use client";
+import { useState, useCallback } from 'react';
+
+function useList(initial = []) {
+  const [items, setItems] = useState(initial);
+  const push = useCallback((item) => {
+    setItems((prev) => [...prev, item]);
+  }, []);
+  const removeAt = useCallback((index) => {
+    setItems((prev) => prev.filter((_, i) => i !== index));
+  }, []);
+  const updateAt = useCallback((index, item) => {
+    setItems((prev) => prev.map((v, i) => i === index ? item : v));
+  }, []);
+  const insertAt = useCallback((index, item) => {
+    setItems((prev) => [...prev.slice(0, index), item, ...prev.slice(index)]);
+  }, []);
+  const clear = useCallback(() => setItems([]), []);
+  const filter = useCallback((fn) => {
+    setItems((prev) => prev.filter(fn));
+  }, []);
+  const sort = useCallback((fn) => {
+    setItems((prev) => [...prev].sort(fn));
+  }, []);
+  return { items, set: setItems, push, removeAt, updateAt, insertAt, clear, filter, sort };
+}
+
+export { useList };

package/dist/hooks/longpress.d.ts

@@ -0,0 +1,10 @@
+interface LongPressHandlers {
+    onMouseDown: (e: React.MouseEvent) => void;
+    onMouseUp: () => void;
+    onMouseLeave: () => void;
+    onTouchStart: (e: React.TouchEvent) => void;
+    onTouchEnd: () => void;
+}
+declare function useLongPress(callback: () => void, delay?: number): LongPressHandlers;
+
+export { type LongPressHandlers, useLongPress };

package/dist/hooks/longpress.js

@@ -0,0 +1,24 @@
+"use client";
+import { useRef, useCallback } from 'react';
+
+function useLongPress(callback, delay = 500) {
+  const timer = useRef(null);
+  const start = useCallback(() => {
+    timer.current = setTimeout(callback, delay);
+  }, [callback, delay]);
+  const cancel = useCallback(() => {
+    if (timer.current) {
+      clearTimeout(timer.current);
+      timer.current = null;
+    }
+  }, []);
+  return {
+    onMouseDown: start,
+    onMouseUp: cancel,
+    onMouseLeave: cancel,
+    onTouchStart: start,
+    onTouchEnd: cancel
+  };
+}
+
+export { useLongPress };

package/dist/hooks/map.d.ts

@@ -0,0 +1,12 @@
+interface MapResult<K, V> {
+    map: Map<K, V>;
+    set: (key: K, value: V) => void;
+    remove: (key: K) => void;
+    has: (key: K) => boolean;
+    get: (key: K) => V | undefined;
+    clear: () => void;
+    reset: () => void;
+}
+declare function useMap<K, V>(initial?: Iterable<[K, V]>): MapResult<K, V>;
+
+export { type MapResult, useMap };

package/dist/hooks/map.js

@@ -0,0 +1,23 @@
+"use client";
+import { useState, useCallback } from 'react';
+
+function useMap(initial) {
+  const [map, setMap] = useState(() => new Map(initial));
+  const set = useCallback((key, value) => {
+    setMap((prev) => new Map(prev).set(key, value));
+  }, []);
+  const remove = useCallback((key) => {
+    setMap((prev) => {
+      const next = new Map(prev);
+      next.delete(key);
+      return next;
+    });
+  }, []);
+  const has = useCallback((key) => map.has(key), [map]);
+  const get = useCallback((key) => map.get(key), [map]);
+  const clear = useCallback(() => setMap(/* @__PURE__ */ new Map()), []);
+  const reset = useCallback(() => setMap(new Map(initial)), [initial]);
+  return { map, set, remove, has, get, clear, reset };
+}
+
+export { useMap };

package/dist/hooks/measure.d.ts

@@ -0,0 +1,16 @@
+interface Rect {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    top: number;
+    right: number;
+    bottom: number;
+    left: number;
+}
+declare function useMeasure<T extends HTMLElement>(): [
+    (node: T | null) => void,
+    Rect
+];
+
+export { type Rect, useMeasure };

package/dist/hooks/measure.js

@@ -0,0 +1,34 @@
+"use client";
+import { useState, useRef, useCallback } from 'react';
+
+const empty = { x: 0, y: 0, width: 0, height: 0, top: 0, right: 0, bottom: 0, left: 0 };
+function useMeasure() {
+  const [rect, setRect] = useState(empty);
+  const observerRef = useRef(null);
+  const ref = useCallback((node) => {
+    if (observerRef.current) {
+      observerRef.current.disconnect();
+      observerRef.current = null;
+    }
+    if (node) {
+      const observer = new ResizeObserver(() => {
+        const r = node.getBoundingClientRect();
+        setRect({
+          x: r.x,
+          y: r.y,
+          width: r.width,
+          height: r.height,
+          top: r.top,
+          right: r.right,
+          bottom: r.bottom,
+          left: r.left
+        });
+      });
+      observer.observe(node);
+      observerRef.current = observer;
+    }
+  }, []);
+  return [ref, rect];
+}
+
+export { useMeasure };

package/dist/hooks/media.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Subscribe to a CSS media query and track its match state.
+ * @param query - CSS media query string (e.g., "(max-width: 768px)")
+ * @returns Whether the media query currently matches
+ */
+declare function useMediaQuery(query: string): boolean;
+/**
+ * Check if viewport is mobile sized (max-width: 768px).
+ * @returns Whether the viewport matches mobile breakpoint
+ */
+declare function useIsMobile(): boolean;
+/**
+ * Check if viewport is tablet sized (769px to 1024px).
+ * @returns Whether the viewport matches tablet breakpoint
+ */
+declare function useIsTablet(): boolean;
+/**
+ * Check if viewport is desktop sized (min-width: 1025px).
+ * @returns Whether the viewport matches desktop breakpoint
+ */
+declare function useIsDesktop(): boolean;
+/**
+ * Check if user prefers dark color scheme.
+ * @returns Whether the user prefers dark mode
+ */
+declare function usePrefersDark(): boolean;
+/**
+ * Check if user prefers reduced motion.
+ * @returns Whether the user prefers reduced motion
+ */
+declare function usePrefersReducedMotion(): boolean;
+
+export { useIsDesktop, useIsMobile, useIsTablet, useMediaQuery, usePrefersDark, usePrefersReducedMotion };

package/dist/hooks/media.js

@@ -0,0 +1,35 @@
+"use client";
+import { useState, useEffect } from 'react';
+
+function useMediaQuery(query) {
+  const [matches, setMatches] = useState(false);
+  useEffect(() => {
+    const mq = window.matchMedia(query);
+    setMatches(mq.matches);
+    function handleChange(e) {
+      setMatches(e.matches);
+    }
+    mq.addEventListener("change", handleChange);
+    return () => {
+      mq.removeEventListener("change", handleChange);
+    };
+  }, [query]);
+  return matches;
+}
+function useIsMobile() {
+  return useMediaQuery("(max-width: 768px)");
+}
+function useIsTablet() {
+  return useMediaQuery("(min-width: 769px) and (max-width: 1024px)");
+}
+function useIsDesktop() {
+  return useMediaQuery("(min-width: 1025px)");
+}
+function usePrefersDark() {
+  return useMediaQuery("(prefers-color-scheme: dark)");
+}
+function usePrefersReducedMotion() {
+  return useMediaQuery("(prefers-reduced-motion: reduce)");
+}
+
+export { useIsDesktop, useIsMobile, useIsTablet, useMediaQuery, usePrefersDark, usePrefersReducedMotion };

package/dist/hooks/mediarecorder.d.ts

@@ -0,0 +1,11 @@
+interface MediaRecorderResult {
+    recording: boolean;
+    blob: Blob | null;
+    url: string | null;
+    supported: boolean;
+    start: (stream: MediaStream) => void;
+    stop: () => void;
+}
+declare function useMediaRecorder(mimeType?: string): MediaRecorderResult;
+
+export { type MediaRecorderResult, useMediaRecorder };

package/dist/hooks/mediarecorder.js

@@ -0,0 +1,37 @@
+"use client";
+import { useState, useRef, useCallback } from 'react';
+
+function useMediaRecorder(mimeType = "audio/webm") {
+  const [recording, setRecording] = useState(false);
+  const [blob, setBlob] = useState(null);
+  const [url, setUrl] = useState(null);
+  const recorderRef = useRef(null);
+  const chunksRef = useRef([]);
+  const supported = typeof window !== "undefined" && "MediaRecorder" in window;
+  const start = useCallback(
+    (stream) => {
+      if (!supported) return;
+      chunksRef.current = [];
+      const recorder = new MediaRecorder(stream, { mimeType });
+      recorder.ondataavailable = (e) => {
+        if (e.data.size > 0) chunksRef.current.push(e.data);
+      };
+      recorder.onstop = () => {
+        const b = new Blob(chunksRef.current, { type: mimeType });
+        setBlob(b);
+        setUrl(URL.createObjectURL(b));
+        setRecording(false);
+      };
+      recorderRef.current = recorder;
+      recorder.start();
+      setRecording(true);
+    },
+    [supported, mimeType]
+  );
+  const stop = useCallback(() => {
+    recorderRef.current?.stop();
+  }, []);
+  return { recording, blob, url, supported, start, stop };
+}
+
+export { useMediaRecorder };

package/dist/hooks/mounted.d.ts

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

package/dist/hooks/mounted.js

@@ -0,0 +1,12 @@
+"use client";
+import { useState, useEffect } from 'react';
+
+function useMounted() {
+  const [mounted, setMounted] = useState(false);
+  useEffect(() => {
+    setMounted(true);
+  }, []);
+  return mounted;
+}
+
+export { useMounted };

package/dist/hooks/mouseposition.d.ts

@@ -0,0 +1,7 @@
+interface MousePosition {
+    x: number;
+    y: number;
+}
+declare function useMousePosition(): MousePosition;
+
+export { type MousePosition, useMousePosition };

package/dist/hooks/mouseposition.js

@@ -0,0 +1,16 @@
+"use client";
+import { useState, useEffect } from 'react';
+
+function useMousePosition() {
+  const [position, setPosition] = useState({ x: 0, y: 0 });
+  useEffect(() => {
+    function handler(e) {
+      setPosition({ x: e.clientX, y: e.clientY });
+    }
+    window.addEventListener("mousemove", handler, { passive: true });
+    return () => window.removeEventListener("mousemove", handler);
+  }, []);
+  return position;
+}
+
+export { useMousePosition };

package/dist/hooks/networkstate.d.ts

@@ -0,0 +1,10 @@
+interface NetworkState {
+    online: boolean;
+    downlink?: number;
+    effectiveType?: string;
+    rtt?: number;
+    saveData?: boolean;
+}
+declare function useNetworkState(): NetworkState;
+
+export { type NetworkState, useNetworkState };

package/dist/hooks/networkstate.js

@@ -0,0 +1,34 @@
+"use client";
+import { useState, useEffect } from 'react';
+
+function getState() {
+  if (typeof navigator === "undefined") return { online: true };
+  const conn = navigator.connection;
+  return {
+    online: navigator.onLine,
+    downlink: conn?.downlink,
+    effectiveType: conn?.effectiveType,
+    rtt: conn?.rtt,
+    saveData: conn?.saveData
+  };
+}
+function useNetworkState() {
+  const [state, setState] = useState(getState);
+  useEffect(() => {
+    function update() {
+      setState(getState());
+    }
+    window.addEventListener("online", update);
+    window.addEventListener("offline", update);
+    const conn = navigator.connection;
+    conn?.addEventListener?.("change", update);
+    return () => {
+      window.removeEventListener("online", update);
+      window.removeEventListener("offline", update);
+      conn?.removeEventListener?.("change", update);
+    };
+  }, []);
+  return state;
+}
+
+export { useNetworkState };

package/dist/hooks/online.d.ts

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

package/dist/hooks/online.js

@@ -0,0 +1,20 @@
+"use client";
+import { useState, useEffect } from 'react';
+
+function useOnline() {
+  const [online, setOnline] = useState(true);
+  useEffect(() => {
+    setOnline(navigator.onLine);
+    const on = () => setOnline(true);
+    const off = () => setOnline(false);
+    window.addEventListener("online", on);
+    window.addEventListener("offline", off);
+    return () => {
+      window.removeEventListener("online", on);
+      window.removeEventListener("offline", off);
+    };
+  }, []);
+  return online;
+}
+
+export { useOnline };

package/dist/hooks/orientation.d.ts

@@ -0,0 +1,8 @@
+interface DeviceOrientation {
+    alpha: number | null;
+    beta: number | null;
+    gamma: number | null;
+}
+declare function useOrientation(): DeviceOrientation;
+
+export { type DeviceOrientation, useOrientation };

package/dist/hooks/orientation.js

@@ -0,0 +1,20 @@
+"use client";
+import { useState, useEffect } from 'react';
+
+function useOrientation() {
+  const [orientation, setOrientation] = useState({
+    alpha: null,
+    beta: null,
+    gamma: null
+  });
+  useEffect(() => {
+    function handler(e) {
+      setOrientation({ alpha: e.alpha, beta: e.beta, gamma: e.gamma });
+    }
+    window.addEventListener("deviceorientation", handler);
+    return () => window.removeEventListener("deviceorientation", handler);
+  }, []);
+  return orientation;
+}
+
+export { useOrientation };

package/dist/hooks/os.d.ts

@@ -0,0 +1,4 @@
+type Platform = "mac" | "windows" | "linux" | "unknown";
+declare function useOs(): Platform;
+
+export { type Platform, useOs };

package/dist/hooks/os.js

@@ -0,0 +1,15 @@
+"use client";
+import { useMemo } from 'react';
+
+function useOs() {
+  return useMemo(() => {
+    if (typeof navigator === "undefined") return "unknown";
+    const ua = navigator.userAgent.toLowerCase();
+    if (ua.includes("mac")) return "mac";
+    if (ua.includes("win")) return "windows";
+    if (ua.includes("linux")) return "linux";
+    return "unknown";
+  }, []);
+}
+
+export { useOs };

package/dist/hooks/pageleave.d.ts

@@ -0,0 +1,3 @@
+declare function usePageLeave(callback: () => void): void;
+
+export { usePageLeave };

package/dist/hooks/pageleave.js

@@ -0,0 +1,18 @@
+"use client";
+import { useRef, useEffect } from 'react';
+
+function usePageLeave(callback) {
+  const saved = useRef(callback);
+  saved.current = callback;
+  useEffect(() => {
+    function handler(e) {
+      if (e.clientY <= 0) {
+        saved.current();
+      }
+    }
+    document.addEventListener("mouseleave", handler);
+    return () => document.removeEventListener("mouseleave", handler);
+  }, []);
+}
+
+export { usePageLeave };

package/dist/hooks/pagination.d.ts

@@ -0,0 +1,26 @@
+import { SidebarSection } from '../components/sidebar.js';
+import 'react';
+import '../content.js';
+import 'zod';
+import '../schema.js';
+
+interface PageLink {
+    href: string;
+    title: string;
+}
+interface PaginationResult {
+    prev: PageLink | null;
+    next: PageLink | null;
+    pages: PageLink[];
+    index: number;
+}
+/**
+ * Flattens navigation tree to linear list for prev/next page navigation
+ * @param navigation - Array of sidebar sections containing navigation items
+ * @param pathname - Current page pathname to find in the navigation
+ * @param basePath - Base path for constructing page hrefs (default: "/docs")
+ * @returns Object containing prev/next links, all pages, and current index
+ */
+declare function usePagination(navigation: SidebarSection[], pathname: string, basePath?: string): PaginationResult;
+
+export { type PageLink, type PaginationResult, usePagination };

package/dist/hooks/pagination.js

@@ -0,0 +1,49 @@
+"use client";
+import { useMemo } from 'react';
+
+const cache = /* @__PURE__ */ new Map();
+function flatten(sections, basePath) {
+  const key = JSON.stringify({ sections, basePath });
+  const cached = cache.get(key);
+  if (cached) return cached;
+  const pages = [];
+  function walk(items) {
+    for (const item of items) {
+      if (!("type" in item)) {
+        pages.push({
+          href: item.slug ? `${basePath}/${item.slug}` : basePath,
+          title: item.title
+        });
+      } else if (item.type === "item") {
+        pages.push({
+          href: item.href,
+          title: item.title
+        });
+      } else if (item.type === "folder") {
+        if (item.href) {
+          pages.push({
+            href: item.href,
+            title: item.title
+          });
+        }
+        walk(item.items);
+      }
+    }
+  }
+  for (const section of sections) {
+    walk(section.items);
+  }
+  cache.set(key, pages);
+  return pages;
+}
+function usePagination(navigation, pathname, basePath = "/docs") {
+  return useMemo(() => {
+    const pages = flatten(navigation, basePath);
+    const index = pages.findIndex((p) => p.href === pathname);
+    const prev = index > 0 ? pages[index - 1] ?? null : null;
+    const next = index >= 0 && index < pages.length - 1 ? pages[index + 1] ?? null : null;
+    return { prev, next, pages, index };
+  }, [navigation, pathname, basePath]);
+}
+
+export { usePagination };

package/dist/hooks/permission.d.ts

@@ -0,0 +1,5 @@
+type PermissionName = "camera" | "microphone" | "geolocation" | "notifications" | "clipboard-read" | "clipboard-write";
+type PermissionState = "granted" | "denied" | "prompt" | "unknown";
+declare function usePermission(name: PermissionName): PermissionState;
+
+export { type PermissionName, type PermissionState, usePermission };

package/dist/hooks/permission.js

@@ -0,0 +1,29 @@
+"use client";
+import { useState, useEffect } from 'react';
+
+function tostate(value) {
+  return value === "granted" || value === "denied" || value === "prompt" ? value : "unknown";
+}
+function usePermission(name) {
+  const [state, setState] = useState("unknown");
+  useEffect(() => {
+    if (typeof navigator === "undefined" || !navigator.permissions) {
+      return;
+    }
+    let mounted = true;
+    navigator.permissions.query({ name }).then((status) => {
+      if (!mounted) return;
+      setState(tostate(status.state));
+      status.addEventListener("change", () => {
+        if (mounted) setState(tostate(status.state));
+      });
+    }).catch(() => {
+    });
+    return () => {
+      mounted = false;
+    };
+  }, [name]);
+  return state;
+}
+
+export { usePermission };

package/dist/hooks/preferredlanguage.d.ts

@@ -0,0 +1,3 @@
+declare function usePreferredLanguage(): string;
+
+export { usePreferredLanguage };

package/dist/hooks/preferredlanguage.js

@@ -0,0 +1,17 @@
+"use client";
+import { useState, useEffect } from 'react';
+
+function usePreferredLanguage() {
+  const [lang, setLang] = useState("en");
+  useEffect(() => {
+    setLang(navigator.language || "en");
+    function handler() {
+      setLang(navigator.language || "en");
+    }
+    window.addEventListener("languagechange", handler);
+    return () => window.removeEventListener("languagechange", handler);
+  }, []);
+  return lang;
+}
+
+export { usePreferredLanguage };

package/dist/hooks/previous.d.ts

@@ -0,0 +1,3 @@
+declare function usePrevious<T>(value: T): T | undefined;
+
+export { usePrevious };

package/dist/hooks/previous.js

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