@xwadex/fesd-next 0.3.4-7.4 → 0.3.4-7.6

package/dist/components/TestComponent.js

@@ -1,10 +1,10 @@
 "use client";
-import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
-import { useCookies } from "../hooks/index.js";
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useAnchors } from "../hooks/index.js";
+import { cn } from "../utils";
 const TestComponent = () => {
-    const cookie = useCookies();
-    console.log(cookie);
-    return (_jsx(_Fragment, { children: "TestComponent content" }));
+    const { registerAnchors, registerContainers, scrollToAnchor } = useAnchors();
+    return (_jsxs("div", { children: [_jsxs("div", { className: "flex flex-col gap-3 fixed top-0 right-0", children: [_jsx("button", { onClick: () => scrollToAnchor({ anchor: "#", }), children: "Scoll to Top" }), _jsx("button", { onClick: () => scrollToAnchor({ anchor: "50", }), children: "Scoll to 50" }), _jsx("button", { onClick: () => scrollToAnchor({ anchor: "100", }), children: "Scoll to 100" })] }), _jsx("h2", { className: "text-xl", children: "TestComponent content" }), _jsx("div", { className: cn("flex flex-col gap-5"), children: Array.from({ length: 200 }).map((_, index) => _jsx("div", { className: cn("p-3", "bg-indigo-600"), ...registerAnchors(String(index)), children: index }, index)) })] }));
 };
 TestComponent.displayName = "TestComponent";
 export default TestComponent;

package/dist/hooks/index.d.ts

@@ -8,3 +8,4 @@ export * from "./useEffectOne";
 export * from "./useEffectLeave";
 export * from "./useAnchors";
 export * from "./useIsMobile";
+export * from "./useHash";

package/dist/hooks/index.js

@@ -8,3 +8,4 @@ export * from "./useEffectOne";
 export * from "./useEffectLeave";
 export * from "./useAnchors";
 export * from "./useIsMobile";
+export * from "./useHash";

package/dist/hooks/useAnchors.d.ts

@@ -1,29 +1,48 @@
 import { Easing } from "motion/react";
 export interface PropsTypes {
 }
-export interface AnchorActionsOptions {
-    anchor?: string;
-    container: string;
-    offseters?: string | string[];
-    direction?: "horizontal" | "vertical" | "both";
+export interface AnimateOptions {
     duration?: number;
-    offset?: number;
     delay?: number;
     ease?: Easing | Easing[] | undefined;
     onScroll?: () => void;
     onScrolling?: (value: number) => void;
     onScrolled?: () => void;
 }
+export interface AnchorOptions extends AnimateOptions {
+    anchor: string;
+    container?: string;
+    offseters?: string | string[];
+    direction?: "x" | "y" | "xy";
+    align?: "start" | "center" | "end";
+    offset?: number;
+}
+export interface ScrollOptions extends AnimateOptions {
+    containerDom: HTMLElement | Window;
+    scrollValue: {
+        x: number;
+        y: number;
+    };
+    containerScrollValue: {
+        left: number;
+        top: number;
+    };
+    direction?: AnchorOptions["direction"];
+}
 export declare function useAnchors(): {
     registerAnchors: typeof registerAnchors;
     registerContainers: typeof registerContainers;
     registerOffseters: typeof registerOffseters;
+    setStores: (states: AnchorStoreStates) => void;
     getStores: () => AnchorsStores;
-    removeAnchor: (name: string) => void;
-    removeOffseter: (name: string) => void;
-    removeContainer: (name: string) => void;
-    scrollToAnchor: (anchorOptions: AnchorActionsOptions) => void;
+    scrollToAnchor: (anchorOptions: AnchorOptions) => void;
 };
+export interface RegistrationDatas {
+    key: keyof AnchorsStores;
+    name: string;
+    node: HTMLDivElement | null;
+}
+export declare function registration({ name, key, node }: RegistrationDatas): void;
 export declare function registerAnchors(name: string): {
     ref: (node: HTMLDivElement | null) => void;
     "data-anchor": string;
@@ -36,16 +55,14 @@ export declare function registerOffseters(name: string): {
     ref: (node: HTMLDivElement | null) => void;
     "data-anchor-offseter": string;
 };
-export type AnchorsStores = {
+export interface AnchorsStores {
     anchors: Map<string, HTMLElement | null>;
     containers: Map<string, HTMLElement | null>;
     offseters: Map<string, HTMLElement | null>;
-};
+}
 export declare const useAnchorsStores: import("zustand").UseBoundStore<import("zustand").StoreApi<AnchorsStores>>;
 export declare const getAnchorsStores: () => AnchorsStores;
-export declare const addAnchor: (name: string, anchorNode: HTMLElement | null) => void;
-export declare const removeAnchor: (name: string) => void;
-export declare const addContainer: (name: string, containerNode: HTMLElement | null) => void;
-export declare const removeContainer: (name: string) => void;
-export declare const addOffseter: (name: string, containerNode: HTMLElement | null) => void;
-export declare const removeOffseter: (name: string) => void;
+export interface AnchorStoreStates extends RegistrationDatas {
+    action: "add" | "remove";
+}
+export declare const setAnchorStore: (states: AnchorStoreStates) => void;

package/dist/hooks/useAnchors.js

@@ -1,148 +1,167 @@
 "use client";
-// update: 2025.10.29
-// version: 0.0.1
+// update: 2025.10.30
+// version: 0.0.1.bate
 // dev: wade
 import { useCallback, useMemo, useRef } from "react";
 import { animate, useMotionValue } from "motion/react";
 import { create } from "zustand";
 export function useAnchors() {
-    const motionValueX = useMotionValue(0);
-    const motionValueY = useMotionValue(0);
-    const animate_x_Ref = useRef(null);
-    const animate_y_Ref = useRef(null);
-    const scrollAnimation = useCallback(({ anchorDom, containerDom, options }) => {
-        if (animate_x_Ref.current)
-            animate_x_Ref.current?.stop();
-        if (animate_y_Ref.current)
-            animate_y_Ref.current?.stop();
-        const { direction = "vertical", duration = 0.5, ease = [0.215, 0.61, 0.355, 1.0], delay = 0, onScroll: onPlay, onScrolled: onScrolled, onScrolling, } = options;
-        const { top: targetTop, left: targetLeft } = anchorDom.getBoundingClientRect();
-        const { top: containerTop, left: containerLeft } = containerDom.getBoundingClientRect();
-        const containerScrollTop = Math.round(containerDom.scrollTop);
-        const containerScrollLeft = Math.round(containerDom.scrollLeft);
-        const verticalOffset = Math.round(targetTop - containerTop + containerScrollTop);
-        const horizontalOffset = Math.round(targetLeft - containerLeft + containerScrollLeft);
-        const isDirectionV = direction === "vertical" || direction === "both";
-        const isDirectionH = direction === "horizontal" || direction === "both";
-        const onUpdate = (value) => {
-            if (isDirectionV)
-                containerDom.scrollTop = value;
-            if (isDirectionH)
-                containerDom.scrollLeft = value;
-            onScrolling?.(value);
+    const motionValue = useMotionValue(0);
+    const animateRef = useRef(null);
+    const scrollAnimations = useCallback(({ containerDom, scrollValue, containerScrollValue, direction = "y", duration = 0.5, delay = 0, ease = [0.215, 0.61, 0.355, 1.0], onScroll, onScrolled, onScrolling }) => {
+        const { left: scrollLeft, top: scrollTop } = containerScrollValue;
+        const { x: scrollX, y: scrollY } = scrollValue;
+        const isScrollX = direction === "x";
+        const isScrollY = direction === "y";
+        const isBoth = direction === "xy";
+        const animationsOptions = {
+            duration,
+            ease,
+            delay,
+            onPlay: onScroll,
+            onUpdate: onUpdate,
+            onComplete: onScrolled,
         };
-        const motionOptions = { duration, ease, delay, onPlay, onScrolled, onUpdate };
-        if (verticalOffset !== containerScrollTop && isDirectionV) {
-            console.log("direction", direction);
-            motionValueY.set(containerScrollTop);
-            animate_y_Ref.current = animate(motionValueY, verticalOffset, motionOptions);
+        if ((isBoth || isScrollX) && (scrollX !== scrollLeft)) {
+            motionValue.set(scrollLeft);
+            animateRef.current = animate(motionValue, scrollX, animationsOptions);
+            return;
         }
-        if (horizontalOffset !== containerScrollLeft && isDirectionH) {
-            motionValueX.set(containerScrollLeft);
-            animate_y_Ref.current = animate(motionValueY, horizontalOffset, motionOptions);
+        if ((isBoth || isScrollY) && (scrollY !== scrollTop)) {
+            motionValue.set(scrollTop);
+            animateRef.current = animate(motionValue, scrollY, animationsOptions);
+            return;
+        }
+        function onUpdate(value) {
+            if (isScrollX)
+                containerDom.scrollTo({ left: value });
+            if (isScrollY)
+                containerDom.scrollTo({ top: value });
+            if (isBoth)
+                containerDom.scrollTo({ top: value, left: value });
+            onScrolling?.(value);
         }
     }, []);
-    const scrollToTop = useCallback((anchorOptions) => {
-    }, [motionValueX, motionValueY]);
     const scrollToAnchor = useCallback((anchorOptions) => {
-        const { anchor: anchorName, container: containerName, offseters, ...options } = anchorOptions;
-        console.log(options);
-        // if (anchorName == "#") return scrollToTop(options)
-        if (containerName == "window")
-            return;
-        if (!anchorName || !containerName)
-            return;
+        if (animateRef.current)
+            animateRef.current?.stop();
+        const { anchor: anchorName, container: containerName, offseters, align, offset = 0, ...options } = anchorOptions;
+        const isContainer = containerName && containerName !== "window";
         const stores = getAnchorsStores();
-        if (!stores?.anchors || !stores?.containers)
-            return;
-        const anchorDom = stores.anchors.get(anchorName);
-        const containerDom = stores.containers.get(containerName);
-        if (!anchorDom || !containerDom)
-            return;
-        scrollAnimation({ anchorDom, containerDom, options });
-    }, [motionValueX, motionValueY]);
+        const containerDom = isContainer
+            ? stores.containers.get(containerName)
+            : window;
+        const containerScrollValue = {
+            top: Math.round(isContainer
+                ? containerDom.scrollTop
+                : containerDom.pageYOffset),
+            left: Math.round(isContainer
+                ? containerDom.scrollLeft
+                : pageXOffset),
+        };
+        const offsetValue = Array.isArray(offseters)
+            ? offseters.reduce((init, offseter) => {
+                const dom = stores.offseters.get(offseter);
+                const width = (init.width ?? 0) + (dom ? dom.clientWidth : 0);
+                const height = (init.height ?? 0) + (dom ? dom.clientHeight : 0);
+                return { width, height };
+            }, {})
+            : { width: 0, height: 0 };
+        const scrollValue = {
+            x: 0 - offsetValue.width,
+            y: 0 - offsetValue.height
+        };
+        const AnimationsOptions = {
+            containerDom, containerScrollValue, scrollValue, ...options
+        };
+        if (anchorName !== "#") {
+            const anchorDom = stores.anchors.get(anchorName);
+            if (!anchorDom)
+                return;
+            const anchorRect = anchorDom.getBoundingClientRect();
+            const containerRect = {
+                left: (isContainer ? containerDom.getBoundingClientRect().left : 0),
+                top: (isContainer ? containerDom.getBoundingClientRect().top : 0)
+            };
+            const offsets = {
+                x: offsetValue.width - offset,
+                y: offsetValue.height - offset
+            };
+            AnimationsOptions.scrollValue = {
+                x: Math.round(anchorRect.left + containerScrollValue.left - offsets.x - containerRect.left),
+                y: Math.round(anchorRect.top + containerScrollValue.top - offsets.y - containerRect.top),
+            };
+        }
+        scrollAnimations(AnimationsOptions);
+    }, []);
     const returnsMemo = useMemo(() => ({
         registerAnchors,
         registerContainers,
         registerOffseters,
+        setStores: setAnchorStore,
         getStores: getAnchorsStores,
-        removeAnchor: removeAnchor,
-        removeOffseter: removeOffseter,
-        removeContainer: removeContainer,
         scrollToAnchor
     }), [scrollToAnchor]);
     return returnsMemo;
 }
+export function registration({ name, key, node }) {
+    if (!node)
+        return;
+    if (name == "#") {
+        console.error(`Cannot register ${key} name '#'`);
+        return;
+    }
+    if (node instanceof Window || node.tagName === "BODY" || node.tagName === "HTML") {
+        console.error(`Cannot register ${key} 'body' or 'html' `);
+        return;
+    }
+    setAnchorStore({ key, name, node, action: node ? "add" : "remove" });
+}
+const ANCHOR_ATTRIBUTE = "data-anchor";
+const CONTAINER_ATTRIBUTE = "data-anchor-container";
+const OFFSETER_ATTRIBUTE = "data-anchor-offseter";
 export function registerAnchors(name) {
-    const register = (node) => {
-        if (name == "#")
-            return console.error("Cannot register anchor  name '#'");
-        if (node)
-            addAnchor(name, node);
-        else
-            removeAnchor(name);
-    };
-    return {
-        ref: register,
-        "data-anchor": name
-    };
+    const register = (node) => registration({ key: "anchors", name, node });
+    return { ref: register, [ANCHOR_ATTRIBUTE]: name };
 }
 export function registerContainers(name) {
-    const register = (node) => {
-        if (name == "window")
-            return console.error("Cannot register anchor container name 'window'");
-        if (!node || node instanceof Window || node.tagName === "BODY" || node.tagName === "HTML")
-            return;
-        if (node)
-            addContainer(name, node);
-        else
-            removeContainer(name);
-    };
-    return {
-        ref: register,
-        "data-anchor-container": name
-    };
+    const register = (node) => registration({ key: "containers", name, node });
+    return { ref: register, [CONTAINER_ATTRIBUTE]: name };
 }
 export function registerOffseters(name) {
-    const register = (node) => {
-        if (node)
-            addOffseter(name, node);
-        else
-            removeOffseter(name);
-    };
-    return {
-        ref: register,
-        "data-anchor-offseter": name
-    };
+    const register = (node) => registration({ key: "offseters", name, node });
+    return { ref: register, [OFFSETER_ATTRIBUTE]: name };
 }
-const anchorsStores = {
+export const useAnchorsStores = create()(() => ({
     anchors: new Map(),
     containers: new Map(),
     offseters: new Map(),
-};
-export const useAnchorsStores = create()(() => anchorsStores);
+}));
 export const getAnchorsStores = () => useAnchorsStores.getState();
-export const addAnchor = (name, anchorNode) => useAnchorsStores.setState(stores => {
-    stores.anchors?.set(name, anchorNode);
-    return { anchors: stores.anchors };
-});
-export const removeAnchor = (name) => useAnchorsStores.setState(stores => {
-    stores.anchors?.delete(name);
-    return { anchors: stores.anchors };
-});
-export const addContainer = (name, containerNode) => useAnchorsStores.setState(stores => {
-    stores.containers?.set(name, containerNode);
-    return { containers: stores.containers };
-});
-export const removeContainer = (name) => useAnchorsStores.setState(stores => {
-    stores.containers?.delete(name);
-    return { containers: stores.containers };
-});
-export const addOffseter = (name, containerNode) => useAnchorsStores.setState(stores => {
-    stores.offseters?.set(name, containerNode);
-    return { offseters: stores.offseters };
-});
-export const removeOffseter = (name) => useAnchorsStores.setState(stores => {
-    stores.offseters?.delete(name);
-    return { offseters: stores.offseters };
-});
+export const setAnchorStore = (states) => {
+    const { key, action, name, node } = states;
+    useAnchorsStores.setState(stores => {
+        switch (key) {
+            case "anchors":
+                if (action == "add" && node instanceof HTMLElement)
+                    stores.anchors?.set(name, node);
+                if (action == "remove")
+                    stores.anchors?.delete(name);
+                return { anchors: stores.anchors };
+            case "containers":
+                if (action == "add" && node instanceof HTMLElement)
+                    stores.containers?.set(name, node);
+                if (action == "remove")
+                    stores.containers?.delete(name);
+                return { containers: stores.containers };
+            case "offseters":
+                if (action == "add" && node instanceof HTMLElement)
+                    stores.offseters?.set(name, node);
+                if (action == "remove")
+                    stores.offseters?.delete(name);
+                return { offseters: stores.offseters };
+            default:
+                return stores;
+        }
+    });
+};

package/dist/hooks/useHash.d.ts

@@ -0,0 +1 @@
+export declare function useHash(): string;

package/dist/hooks/useHash.js

@@ -0,0 +1,19 @@
+"use client";
+import { useEffect, useState } from "react";
+export function useHash() {
+    const [hash, setHash] = useState("");
+    const updateHash = () => setHash(window.location.hash);
+    const hashchangeEvent = (e) => {
+        e.preventDefault?.();
+        updateHash();
+    };
+    // 初始化
+    useEffect(() => {
+        updateHash();
+        window.addEventListener("hashchange", hashchangeEvent);
+        return () => {
+            window.removeEventListener("hashchange", hashchangeEvent);
+        };
+    }, []);
+    return hash;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@xwadex/fesd-next",
-	"version": "0.3.4-7.4",
+	"version": "0.3.4-7.6",
 	"private": false,
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",