@xwadex/fesd-next 0.3.4-7.2 → 0.3.4-7.21

package/dist/components/puck-contents/puck-contents-editor.d.ts

@@ -0,0 +1,5 @@
+export interface PropsTypes extends React.ComponentProps<"div"> {
+    previewRoute?: string;
+}
+declare const PuckContentsEditor: React.FC<PropsTypes>;
+export default PuckContentsEditor;

package/dist/components/puck-contents/puck-contents-editor.js

@@ -0,0 +1,27 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Puck } from "@puckeditor/core";
+import { editorConfig, editorConfigOverrides } from "./puck-configs";
+import { useState } from "react";
+import { useRouter } from "next/navigation";
+const PuckContentsEditor = ({ previewRoute = "/puck/previews" }) => {
+    const [state, setstate] = useState({});
+    const router = useRouter();
+    const save = (data) => {
+        console.log(data);
+        setstate(prev => ({ ...prev, data }));
+        router.push(`${previewRoute ?? "/previews"}?data=` + JSON.stringify(data));
+    };
+    return (_jsx(Puck, { config: editorConfig, data: {}, onPublish: save, overrides: editorConfigOverrides, height: "100%", 
+        // _experimentalFullScreenCanvas
+        plugins: [
+        // headingAnalyzer,
+        // MyPlugin,
+        // outline,
+        // blocks,
+        // legacySideBar,
+        // fields
+        ] }));
+};
+PuckContentsEditor.displayName = "PuckContentsEditor";
+export default PuckContentsEditor;

package/dist/components/puck-contents/puck-contents-rander.d.ts

@@ -0,0 +1,5 @@
+export interface PropsTypes extends React.ComponentProps<"div"> {
+    datas?: any;
+}
+declare const PuckContentsRander: React.FC<PropsTypes>;
+export default PuckContentsRander;

package/dist/components/puck-contents/puck-contents-rander.js

@@ -0,0 +1,14 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Render } from "@puckeditor/core";
+import { renderConfig } from "./puck-configs";
+import { initialData } from "./puck-inital-datas";
+import { useEffect } from "react";
+const PuckContentsRander = ({ datas }) => {
+    useEffect(() => {
+        console.log(datas);
+    }, [datas]);
+    return (_jsx(Render, { "data-id": "wade", config: renderConfig, data: datas ?? initialData }));
+};
+PuckContentsRander.displayName = "PuckContentsRander";
+export default PuckContentsRander;

package/dist/components/puck-contents/puck-inital-datas.d.ts

@@ -0,0 +1,46 @@
+export declare const initialData: {
+    root: {
+        props: {
+            title: string;
+            description: string;
+            content: never[];
+        };
+    };
+    content: {
+        type: string;
+        props: {
+            mediaBlock: {
+                type: string;
+                props: {
+                    id: string;
+                    imgs: string;
+                    alt: string;
+                };
+            }[];
+            textBlock: {
+                type: string;
+                props: {
+                    id: string;
+                    title: string;
+                    subTitle: string;
+                    description: string;
+                    titleOptions: {
+                        content2: string;
+                        tage2: string;
+                        color2: string;
+                        align2: string;
+                    };
+                };
+            }[];
+            options: {
+                textAlign: string;
+                textAlign2: string;
+            };
+            background: {
+                isImage: string;
+            };
+            id: string;
+        };
+    }[];
+    zones: {};
+};

package/dist/components/puck-contents/puck-inital-datas.js

@@ -0,0 +1,92 @@
+export const initialData = {
+    "root": {
+        "props": {
+            "title": "Hello, world",
+            "description": "Lorem ipsum",
+            "content": []
+        }
+    },
+    "content": [
+        {
+            "type": "Base Block",
+            "props": {
+                "mediaBlock": [
+                    {
+                        "type": "MediaContent",
+                        "props": {
+                            "id": "MediaContent-168337f3-0b6f-43d8-8850-6f402eedcb65",
+                            "imgs": "/01.png",
+                            "alt": "alt"
+                        }
+                    }
+                ],
+                "textBlock": [
+                    {
+                        "type": "TextContent",
+                        "props": {
+                            "id": "TextContent-5679409f-98c3-40b5-8a80-ab322f90695f",
+                            "title": "Content that adapts to your layout",
+                            "subTitle": "Designed for clarity and consistency",
+                            "description": "This section supports flexible content placement and alignment across different screen sizes.",
+                            "titleOptions": {
+                                "content2": "Content that adapts to your layout",
+                                "tage2": "h3",
+                                "color2": "",
+                                "align2": "left"
+                            }
+                        }
+                    }
+                ],
+                "options": {
+                    "textAlign": "left",
+                    "textAlign2": "top"
+                },
+                "background": {
+                    "isImage": "no"
+                },
+                "id": "Base Block-aff75e04-815f-4014-97df-83f886fb5f76"
+            }
+        },
+        {
+            "type": "Base Block",
+            "props": {
+                "mediaBlock": [
+                    {
+                        "type": "MediaContent",
+                        "props": {
+                            "id": "MediaContent-d8dd3ec5-7b3d-487d-81d8-56468bf517be",
+                            "imgs": "/01.png",
+                            "alt": "alt"
+                        }
+                    }
+                ],
+                "textBlock": [
+                    {
+                        "type": "TextContent",
+                        "props": {
+                            "id": "TextContent-0c983fb1-559e-4c82-8830-4e1b3ada07d4",
+                            "title": "Content that adapts to your layout",
+                            "subTitle": "Designed for clarity and consistency",
+                            "description": "This section supports flexible content placement and alignment across different screen sizes.",
+                            "titleOptions": {
+                                "content2": "Content that adapts to your layout",
+                                "tage2": "h3",
+                                "color2": "",
+                                "align2": "left"
+                            }
+                        }
+                    }
+                ],
+                "options": {
+                    "textAlign": "right",
+                    "textAlign2": "top"
+                },
+                "background": {
+                    "isImage": "no"
+                },
+                "id": "Base Block-494258fc-5ee2-4403-9788-acb8824205d8"
+            }
+        }
+    ],
+    "zones": {}
+};

package/dist/components/scroll-containers/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./native-scroll";
+export * from "./lenis-scroll";
+export * from "./scroll-containers";

package/dist/components/scroll-containers/index.js

@@ -0,0 +1,3 @@
+export * from "./native-scroll";
+export * from "./lenis-scroll";
+export * from "./scroll-containers";

package/dist/components/scroll-containers/lenis-scroll.d.ts

@@ -0,0 +1,20 @@
+import Lenis from 'lenis';
+import type { LenisOptions } from "lenis";
+export interface LenisScrollProps {
+    root?: boolean | "asChild";
+    name?: string;
+    options?: LenisOptions;
+    children?: React.ReactNode;
+    className?: string;
+}
+export declare const LenisScroll: React.FC<LenisScrollProps>;
+export declare const LenisRootScroll: React.FC<LenisScrollProps>;
+type LenisScrollContainerProps = Omit<LenisScrollProps, "root">;
+export declare const LenisContainerScroll: React.FC<LenisScrollContainerProps>;
+interface LenisStores {
+    root?: Lenis | null;
+}
+export declare const useLenisStores: import("zustand").UseBoundStore<import("zustand").StoreApi<LenisStores>>;
+export declare const setRootLenis: (lenis: Lenis) => void;
+export declare const getRootLenis: () => LenisStores;
+export {};

package/dist/components/scroll-containers/lenis-scroll.js

@@ -0,0 +1,66 @@
+"use client";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+// update: 2025.11.12
+// version: 0.0.1.bate
+// dev: wade
+import { memo, useEffect, useEffectEvent, useLayoutEffect, useRef, useState } from "react";
+import { ReactLenis, useLenis, } from "lenis/react";
+import Lenis from 'lenis';
+import { create } from "zustand";
+import { ScrollContainerContext, setScrollContainerStore } from "./scroll-containers";
+import { cn } from "../../shadcns/index.js";
+export const LenisScroll = memo((props) => {
+    return (_jsxs(_Fragment, { children: [props?.root == true
+                ? _jsx(LenisRootScroll, { ...props })
+                : _jsx(LenisContainerScroll, { ...props }), "\t"] }));
+});
+export const LenisRootScroll = memo(({ root, options }) => {
+    const lenis = useLenis();
+    const lenisRef = useRef(null);
+    const registerRootLenis = useEffectEvent(() => {
+        if (!root == true || !lenis)
+            return;
+        setRootLenis(lenis);
+    });
+    useEffect(() => { registerRootLenis(); }, [lenis]);
+    return (_jsx(ReactLenis, { ref: lenisRef, root: root, options: {
+            autoRaf: true,
+            lerp: 0.0005,
+            duration: 1.5,
+            smoothWheel: true,
+            ...options
+        } }));
+});
+export const LenisContainerScroll = memo(({ name, className, children, options, ...restProps }) => {
+    const [containerRef, setContainerRef] = useState();
+    const wrapperRef = useRef(null);
+    const contentRef = useRef(null);
+    const initLenis = useEffectEvent(() => {
+        if (!wrapperRef.current || !contentRef.current || !name)
+            return;
+        const lenis = new Lenis({
+            wrapper: wrapperRef.current,
+            content: contentRef.current,
+            autoRaf: true,
+            ...options
+        });
+        setContainerRef(contentRef);
+        setScrollContainerStore({ name, action: "add", node: lenis });
+        return () => {
+            setScrollContainerStore({ name, action: "remove" });
+            lenis?.destroy?.();
+        };
+    });
+    useLayoutEffect(() => {
+        const effect = initLenis();
+        return effect;
+    }, [name, options]);
+    return (_jsx("div", { ref: wrapperRef, "data-lenis-scroll": name, className: cn("group overflow-hidden", className), ...restProps, children: _jsx("div", { ref: contentRef, className: cn("h-full", "relative", "will-change-transform overscroll-contain"), children: _jsx(ScrollContainerContext, { value: { containerRef }, children: children }) }) }));
+});
+export const useLenisStores = create()(() => ({
+    root: null,
+}));
+export const setRootLenis = (lenis) => useLenisStores.setState(() => {
+    return { root: lenis };
+});
+export const getRootLenis = () => useLenisStores.getState();

package/dist/components/scroll-containers/native-scroll.d.ts

@@ -0,0 +1,6 @@
+type PropsType<T extends React.ElementType = "div"> = React.ComponentProps<T> & {
+    name: string;
+    tag?: T;
+};
+export declare const NativeScroll: import("react").MemoExoticComponent<(<T extends React.ElementType = "div">({ tag: Component, name, className, ...restProps }: PropsType<T>) => import("react/jsx-runtime").JSX.Element)>;
+export {};

package/dist/components/scroll-containers/native-scroll.js

@@ -0,0 +1,24 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+// update: 2025.11.12
+// version: 0.0.1.bate
+// dev: wade
+import { memo, useEffectEvent, useEffect, useRef, useState } from "react";
+import { ScrollContainerContext, setScrollContainerStore } from "./scroll-containers";
+import { cn } from "../../shadcns/index.js";
+export const NativeScroll = memo(({ tag: Component = "div", name, className, ...restProps }) => {
+    const componentRef = useRef(null);
+    const [containerRef, setContainerRef] = useState();
+    const nativeEffect = useEffectEvent(() => {
+        if (!componentRef.current)
+            return;
+        setContainerRef(componentRef);
+        setScrollContainerStore({ name, action: "add", node: componentRef.current });
+        return () => { setScrollContainerStore({ name, action: "remove" }); };
+    });
+    useEffect(() => {
+        const effect = nativeEffect();
+        return effect;
+    }, [componentRef?.current]);
+    return (_jsx(ScrollContainerContext, { value: { containerRef }, children: _jsx(Component, { ref: componentRef, "data-native-scroll": name, className: cn("overflow-auto", "will-change-transform", className), ...restProps }) }));
+});

package/dist/components/scroll-containers/scroll-containers.d.ts

@@ -0,0 +1,25 @@
+import Lenis from "lenis";
+import { LenisScrollProps } from "./lenis-scroll";
+type PropsType<T extends React.ElementType = "div"> = React.ComponentProps<T> & LenisScrollProps & {
+    name: string;
+    lenis?: boolean;
+};
+export declare const ScrollContainer: <T extends React.ElementType = "div">({ name, lenis, ...props }: PropsType<T>) => import("react/jsx-runtime").JSX.Element;
+export interface ScrollContainerContext {
+    containerRef: React.RefObject<HTMLDivElement | null> | undefined;
+}
+export declare const ScrollContainerContext: import("react").Context<ScrollContainerContext | null>;
+export declare const useScrollContainerContext: () => ScrollContainerContext;
+export interface ScrollContainersStores {
+    containers: Map<string, Lenis | HTMLDivElement | null>;
+}
+export declare const useScrollContainersStores: import("zustand").UseBoundStore<import("zustand").StoreApi<ScrollContainersStores>>;
+export declare const getScrollContainer: (name: string) => HTMLDivElement | Lenis | null | undefined;
+export declare const getScrollContainerStores: () => ScrollContainersStores;
+export interface SetStoreOptions {
+    name: string;
+    node?: Lenis | HTMLDivElement | null;
+    action: "add" | "remove";
+}
+export declare const setScrollContainerStore: (options: SetStoreOptions) => void;
+export {};

package/dist/components/scroll-containers/scroll-containers.js

@@ -0,0 +1,47 @@
+"use client";
+import { jsx as _jsx, Fragment as _Fragment } from "react/jsx-runtime";
+// update: 2025.11.12
+// version: 0.0.1.bate
+// dev: wade
+import { createContext, use } from "react";
+import Lenis from "lenis";
+import { create } from "zustand";
+import { NativeScroll } from "./native-scroll";
+import { LenisScroll } from "./lenis-scroll";
+export const ScrollContainer = ({ name, lenis = false, ...props }) => {
+    return (_jsx(_Fragment, { children: lenis
+            ? _jsx(LenisScroll, { name: name, ...props })
+            : _jsx(NativeScroll, { name: name, ...props }) }));
+};
+export const ScrollContainerContext = createContext(null);
+export const useScrollContainerContext = () => {
+    const context = use(ScrollContainerContext);
+    if (!context)
+        throw new Error("useScrollContainerContext must be used inside ScrollContainerProvider");
+    return context;
+};
+export const useScrollContainersStores = create()(() => ({
+    containers: new Map(),
+}));
+export const getScrollContainer = (name) => {
+    const stores = useScrollContainersStores.getState();
+    return stores.containers?.get(name);
+};
+export const getScrollContainerStores = () => useScrollContainersStores.getState();
+export const setScrollContainerStore = (options) => {
+    const { action, name, node } = options;
+    useScrollContainersStores.setState(stores => {
+        const containerDom = stores.containers?.get(name);
+        const isContainerNode = node instanceof Lenis || node instanceof HTMLDivElement;
+        if (action == "add" && isContainerNode) {
+            if (containerDom == node)
+                return stores;
+            // console.log("node", node, name);
+            stores.containers?.set(name, node);
+        }
+        else if (action == "remove" && containerDom) {
+            stores.containers?.delete(name);
+        }
+        return { containers: stores.containers };
+    });
+};

package/dist/components/tests/index.d.ts

@@ -0,0 +1 @@
+export { default as Tests } from "./tests";

package/dist/components/tests/index.js

@@ -0,0 +1 @@
+export { default as Tests } from "./tests";

package/dist/components/tests/tests.d.ts

@@ -0,0 +1,4 @@
+export interface PropsTypes {
+}
+declare const Tests: React.FC<PropsTypes>;
+export default Tests;

package/dist/components/tests/tests.js

@@ -0,0 +1,10 @@
+"use client";
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button } from "../../shadcns/index.js";
+import { CarouselPrevious } from "../../shadcns/index.js";
+import { Carousel } from "../../shadcns/index.js";
+const Tests = () => {
+    return (_jsxs(_Fragment, { children: [_jsx(Carousel, { children: _jsx(CarouselPrevious, {}) }), _jsx(Button, { children: "test123133232" })] }));
+};
+Tests.displayName = "Tests";
+export default Tests;

package/dist/hooks/index.d.ts

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

package/dist/hooks/index.js

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

package/dist/hooks/useAnchors.d.ts

@@ -1,51 +1,66 @@
-import { Easing } from "motion/react";
-export interface PropsTypes {
-}
-export interface AnchorActionsOptions {
-    anchor?: string;
-    container: string;
-    offseters?: string | string[];
-    direction?: "horizontal" | "vertical";
+import type { AnimationPlaybackControlsWithThen, Easing } from "motion/react";
+import Lenis from "lenis";
+export interface AnimateOptions {
     duration?: number;
-    offset?: number;
     delay?: number;
     ease?: Easing | Easing[] | undefined;
-    onScroll?: () => void;
+    onScroll?: (lenis?: Lenis) => void;
     onScrolling?: (value: number) => void;
-    onScrolled?: () => void;
+    onScrolled?: (lenis?: Lenis) => void;
+}
+export interface AnchorOptions extends AnimateOptions {
+    anchor: string;
+    container?: string;
+    offseters?: string | string[];
+    direction?: "x" | "y";
+    align?: "start" | "center" | "end";
+    offset?: number;
+}
+export interface ScrollOptions extends AnimateOptions {
+    controllerKey: string;
+    containerDom: HTMLElement | Window;
+    anchorScrollValue: {
+        left: number;
+        top: number;
+    };
+    containerScrollValue: {
+        left: number;
+        top: number;
+    };
+    direction?: AnchorOptions["direction"];
 }
+export type AnimateController = AnimationPlaybackControlsWithThen;
 export declare function useAnchors(): {
     registerAnchors: typeof registerAnchors;
-    registerContainers: typeof registerContainers;
     registerOffseters: typeof registerOffseters;
+    setStores: (options: AnchorStoreOptions) => void;
     getStores: () => AnchorsStores;
-    removeAnchor: (name: string) => void;
-    removeOffseter: (name: string) => void;
-    removeContainer: (name: string) => void;
-    scrollToAnchor: ({ anchor: anchorName, container: containerName, ...options }: AnchorActionsOptions) => void;
+    scrollToAnchor: (anchorOptions: AnchorOptions) => void;
+};
+export interface RegistrationDatas {
+    key: keyof AnchorsStores;
+    name: string;
+}
+export declare function useRegistration({ key, name }: RegistrationDatas): {
+    [x: string]: string | import("react").RefObject<null>;
+    ref: import("react").RefObject<null>;
 };
 export declare function registerAnchors(name: string): {
-    ref: (node: HTMLDivElement | null) => void;
-    "data-anchor": string;
+    [x: string]: string | import("react").RefObject<null>;
+    ref: import("react").RefObject<null>;
 };
 export declare function registerOffseters(name: string): {
-    ref: (node: HTMLDivElement | null) => void;
-    "data-anchor-offseter": string;
-};
-export declare function registerContainers(name: string): {
-    ref: (node: HTMLDivElement | null) => void;
-    "data-anchor-container": string;
+    [x: string]: string | import("react").RefObject<null>;
+    ref: import("react").RefObject<null>;
 };
-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 AnchorStoreOptions extends RegistrationDatas {
+    node: HTMLDivElement | null;
+    action: "add" | "remove";
+}
+export declare const setAnchorsStore: (options: AnchorStoreOptions) => void;