@rnaga/wp-next-admin 1.0.1

package/client/hooks/use-admin-navigation.d.ts

@@ -0,0 +1,39 @@
+import queryString from "querystring";
+import * as types from "../../types";
+import type * as wpCoreTypes from "@rnaga/wp-next-core/types";
+export declare const useAdminNavigation: <Params = Record<string, any>>() => {
+    pathname: string;
+    basePath: string;
+    blogBasePath: string;
+    searchParams: import("next/navigation").ReadonlyURLSearchParams;
+    navigationStatus: string;
+    router: import("next/dist/shared/lib/app-router-context.shared-runtime").AppRouterInstance;
+    currentPath: string;
+    resolvePath: (segment: types.client.AdminPageSegment, options?: Partial<{
+        absolute: boolean;
+        append: string;
+        queryParams?: queryString.ParsedUrlQueryInput;
+    }>) => string;
+    gotoPath: (path: string, options?: Partial<{
+        segment: types.client.AdminPageSegment;
+        queryParams?: queryString.ParsedUrlQueryInput;
+    }>) => void;
+    queryObject: Params;
+    createQueryObject: (params?: Params | undefined, options?: {
+        update: boolean;
+    }) => any;
+    createQueryString: (params?: Params | undefined, options?: {
+        update: boolean;
+    }) => string;
+    pushRouter: (params?: Params | undefined) => void;
+    updateRouter: (params?: Params | undefined) => void;
+    goto: (path: string) => void;
+    refresh: (keys?: (keyof wpCoreTypes.client.GlobalState["layout-keys"])[]) => void;
+    refreshValue: () => {
+        header: number;
+        sidebar: number;
+        main: number;
+        content: number;
+    };
+};
+//# sourceMappingURL=use-admin-navigation.d.ts.map

package/client/hooks/use-admin-navigation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-admin-navigation.d.ts","sourceRoot":"","sources":["../../../src/client/hooks/use-admin-navigation.ts"],"names":[],"mappings":"AAAA,OAAO,WAAW,MAAM,aAAa,CAAC;AAItC,OAAO,KAAK,KAAK,MAAM,aAAa,CAAC;AAGrC,OAAO,KAAK,KAAK,WAAW,MAAM,2BAA2B,CAAC;AAM9D,eAAO,MAAM,kBAAkB,GAAI,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;;;;;;;;2BAgDlD,KAAK,CAAC,MAAM,CAAC,gBAAgB,YAC5B,OAAO,CAAC;QAChB,QAAQ,EAAE,OAAO,CAAC;QAClB,MAAM,EAAE,MAAM,CAAC;QACf,WAAW,CAAC,EAAE,WAAW,CAAC,mBAAmB,CAAC;KAC/C,CAAC,KACD,MAAM;qBAWD,MAAM,YACF,OAAO,CAAC;QAChB,OAAO,EAAE,KAAK,CAAC,MAAM,CAAC,gBAAgB,CAAC;QACvC,WAAW,CAAC,EAAE,WAAW,CAAC,mBAAmB,CAAC;KAC/C,CAAC;;;;;;;;;;;qBA/CK,CAAC,MAAM,WAAW,CAAC,MAAM,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,EAAE;;;;;;;CAgFjE,CAAC"}

package/client/hooks/use-admin-navigation.js

@@ -0,0 +1,61 @@
+import queryString from "querystring";
+import { useNavigation } from "@rnaga/wp-next-core/client/hooks/use-navigation";
+import { useWPAdmin } from "../wp-admin";
+export const useAdminNavigation = () => {
+    const { pathname, searchParams, navigationStatus, router, queryObject, pushRouter, updateRouter, goto, createQueryObject, createQueryString, } = useNavigation();
+    const { site: { basePath, blogBasePath }, wp: { globalState }, } = useWPAdmin();
+    const layoutKeys = globalState.get("layout-keys");
+    const refresh = (keys) => {
+        const defaults = { header: 1, sidebar: 2, main: 3, content: 4 };
+        const generateKeyValue = (key) => {
+            return keys?.includes(key)
+                ? Math.random()
+                : layoutKeys?.[key] ?? defaults[key];
+        };
+        const newKeys = {
+            header: generateKeyValue("header"),
+            sidebar: generateKeyValue("sidebar"),
+            main: generateKeyValue("main"),
+            content: generateKeyValue("content"),
+        };
+        globalState.set("layout-keys", newKeys);
+    };
+    const refreshValue = () => globalState.get("layout-keys");
+    const currentPath = pathname.replace(new RegExp(`^${blogBasePath}`), "");
+    const resolvePath = (segment, options) => {
+        const { absolute = true, append = "", queryParams } = options ?? {};
+        const prepend = absolute ? blogBasePath : currentPath;
+        const query = queryParams ? `?${queryString.stringify(queryParams)}` : "";
+        return `${prepend}/${String(segment)}${append ?? ""}${query}`;
+    };
+    const currentPageSegment = globalState.get("page-segment");
+    const gotoPath = (path, options) => {
+        const segment = options?.segment ?? currentPageSegment;
+        if (!segment) {
+            throw new Error("Segment is not defined.");
+        }
+        goto(resolvePath(segment, {
+            queryParams: options?.queryParams,
+            append: path,
+        }));
+    };
+    return {
+        pathname,
+        basePath,
+        blogBasePath,
+        searchParams,
+        navigationStatus,
+        router,
+        currentPath,
+        resolvePath,
+        gotoPath,
+        queryObject,
+        createQueryObject,
+        createQueryString,
+        pushRouter,
+        updateRouter,
+        goto,
+        refresh,
+        refreshValue,
+    };
+};

package/client/hooks/use-admin-server-actions.d.ts

@@ -0,0 +1,49 @@
+import * as actionsDashboard from "../../server/actions/dashboard";
+export declare const useAdminServerActions: () => {
+    actions: {
+        dashboard: typeof actionsDashboard;
+        adminUser: typeof import("@rnaga/wp-next-core/server/actions/admin-user");
+        site: typeof import("@rnaga/wp-next-core/server/actions/site");
+        user: typeof import("@rnaga/wp-next-core/server/actions/user");
+        blog: typeof import("@rnaga/wp-next-core/server/actions/blog");
+        media: typeof import("@rnaga/wp-next-core/server/actions/media");
+        meta: typeof import("@rnaga/wp-next-core/server/actions/meta");
+        options: typeof import("@rnaga/wp-next-core/server/actions/options");
+        post: typeof import("@rnaga/wp-next-core/server/actions/post");
+        revision: typeof import("@rnaga/wp-next-core/server/actions/revision");
+        roles: typeof import("@rnaga/wp-next-core/server/actions/roles");
+        term: typeof import("@rnaga/wp-next-core/server/actions/term");
+        comment: typeof import("@rnaga/wp-next-core/server/actions/comment");
+        password: {
+            requestResetKey: (userLogin: string) => Promise<import("@rnaga/wp-next-core/types/server-actions.d").ErrorResponsePayload | {
+                success: true;
+                error: undefined;
+                data: boolean;
+                info: unknown;
+            } | {
+                success: true;
+                error: undefined;
+                data: string;
+                info: unknown;
+            }>;
+        };
+    };
+    execute: <T extends {
+        data: any;
+        info: any;
+    }>(serverAction: Promise<T>) => Promise<import("@rnaga/wp-next-core/types/server-actions.d").ReponsePayload<T>>;
+    loading: boolean;
+    parse: <T extends import("@rnaga/wp-next-core/types/server-actions.d").ReponsePayload<T>>(response: T) => [NonNullable<T["data"]>, T["info"]];
+    safeParse: <T extends import("@rnaga/wp-next-core/types/server-actions.d").ReponsePayload<T>>(response: T) => {
+        success: true;
+        data: NonNullable<T["data"]>;
+        info: T["info"];
+        error: never;
+    } | {
+        success: false;
+        data: never;
+        info: never;
+        error: string;
+    };
+};
+//# sourceMappingURL=use-admin-server-actions.d.ts.map

package/client/hooks/use-admin-server-actions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-admin-server-actions.d.ts","sourceRoot":"","sources":["../../../src/client/hooks/use-admin-server-actions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,gBAAgB,MAAM,gCAAgC,CAAC;AAInE,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAYjC,CAAC"}

package/client/hooks/use-admin-server-actions.js

@@ -0,0 +1,13 @@
+import * as actionsDashboard from "../../server/actions/dashboard";
+import { useServerActions } from "@rnaga/wp-next-core/client/hooks/use-server-actions";
+export const useAdminServerActions = () => {
+    const serverActions = useServerActions();
+    const actions = {
+        ...serverActions.actions,
+        dashboard: actionsDashboard,
+    };
+    return {
+        ...serverActions,
+        actions,
+    };
+};

package/client/hooks/use-admin-user.d.ts

@@ -0,0 +1,130 @@
+export declare const useAdminUser: () => {
+    updateAdminUser: () => Promise<void>;
+    adminUser: {
+        role: {
+            names: Set<string>;
+            capabilities: Set<string>;
+        };
+        availableSites: {
+            user: import("@rnaga/wp-node/types").WpUsers;
+            primary_blog: Pick<NonNullable<{
+                blog_id: number;
+                site_id: number;
+                blog_roles: Record<string, {
+                    name: string;
+                    capabilities: string[];
+                }>;
+                blogname: string;
+                rolenames: string[];
+                capabilities: string[];
+                sitename: string;
+                siteurl: string;
+            } | {
+                capabilities: string[];
+                blog_id: number;
+                domain: string;
+                path: string;
+                site_id: number;
+                siteurl: string | undefined;
+                archived: number;
+                spam: number;
+                deleted: number;
+                rolenames: string[] | undefined;
+                blog_roles: Record<string, import("@rnaga/wp-node/types").Role>;
+                blogname: string | undefined;
+            }> & {
+                blog_id: number;
+                domain: string;
+                path: string;
+                site_id: number;
+                siteurl: string | undefined;
+                archived: number;
+                spam: number;
+                deleted: number;
+                rolenames: string[] | undefined;
+                blog_roles: Record<string, import("@rnaga/wp-node/types").Role>;
+                blogname: string | undefined;
+            }, "capabilities" | "site_id" | "blog_id" | "blogname" | "rolenames"> & {
+                blog_roles: Record<string, import("@rnaga/wp-node/types").Role> | undefined;
+            };
+            is_multisite: boolean;
+            sites: undefined | {
+                site_id: number;
+                sitename: string;
+                siteurl: string;
+                is_superadmin: boolean;
+                blogs: (Pick<NonNullable<{
+                    blog_id: number;
+                    site_id: number;
+                    blog_roles: Record<string, {
+                        name: string;
+                        capabilities: string[];
+                    }>;
+                    blogname: string;
+                    rolenames: string[];
+                    capabilities: string[];
+                    sitename: string;
+                    siteurl: string;
+                } | {
+                    capabilities: string[];
+                    blog_id: number;
+                    domain: string;
+                    path: string;
+                    site_id: number;
+                    siteurl: string | undefined;
+                    archived: number;
+                    spam: number;
+                    deleted: number;
+                    rolenames: string[] | undefined;
+                    blog_roles: Record<string, import("@rnaga/wp-node/types").Role>;
+                    blogname: string | undefined;
+                }> & {
+                    blog_id: number;
+                    domain: string;
+                    path: string;
+                    site_id: number;
+                    siteurl: string | undefined;
+                    archived: number;
+                    spam: number;
+                    deleted: number;
+                    rolenames: string[] | undefined;
+                    blog_roles: Record<string, import("@rnaga/wp-node/types").Role>;
+                    blogname: string | undefined;
+                }, "capabilities" | "site_id" | "blog_id" | "blogname" | "rolenames"> & {
+                    blog_roles: Record<string, import("@rnaga/wp-node/types").Role> | undefined;
+                })[] | undefined;
+            }[];
+        };
+        ID: number;
+        user_login: string;
+        user_pass: string;
+        user_nicename: string;
+        user_email: string;
+        user_activation_key: string;
+        user_status: number;
+        display_name: string;
+        spam: number;
+        deleted: number;
+        user_url?: string;
+        user_registered?: string;
+    };
+    user: {
+        role: {
+            names: Set<string>;
+            capabilities: Set<string>;
+        };
+        ID: number;
+        user_login: string;
+        user_nicename: string;
+        user_email: string;
+        user_status: number;
+        display_name: string;
+        spam: number;
+        deleted: number;
+        user_url?: string;
+        user_registered?: string;
+    };
+    updateUser: () => Promise<void>;
+    userCan: <T extends keyof import("@rnaga/wp-next-core/client/utils").MapMetaCapArgs>(action: T, ...args: import("@rnaga/wp-next-core/client/utils").MapMetaCapArgs[T]) => boolean;
+};
+//# sourceMappingURL=use-admin-user.d.ts.map

package/client/hooks/use-admin-user.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-admin-user.d.ts","sourceRoot":"","sources":["../../../src/client/hooks/use-admin-user.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAQM,CAAC;uBAAiC,CAAC;;;oGAM7D,GAAI;CAKR,CAAC"}

package/client/hooks/use-admin-user.js

@@ -0,0 +1,19 @@
+import { useUser } from "@rnaga/wp-next-core/client/hooks/use-user";
+import { useServerActions } from "@rnaga/wp-next-core/client/hooks/use-server-actions";
+import { useWP } from "@rnaga/wp-next-core/client/wp";
+export const useAdminUser = () => {
+    const { globalState } = useWP();
+    const { actions, safeParse } = useServerActions();
+    const user = useUser();
+    const updateAdminUser = async () => {
+        const response = await actions.adminUser.getAdminCurrent().then(safeParse);
+        if (response.success) {
+            globalState.set("adminUser", response.data);
+        }
+    };
+    return {
+        ...user,
+        updateAdminUser,
+        adminUser: globalState.get("adminUser"),
+    };
+};

package/client/hooks/use-current-menu.d.ts

@@ -0,0 +1,3 @@
+import type * as types from "../../types";
+export declare const useCurrentMenu: () => [types.client.AdminMenu, types.client.AdminMenu | undefined] | undefined;
+//# sourceMappingURL=use-current-menu.d.ts.map

package/client/hooks/use-current-menu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-current-menu.d.ts","sourceRoot":"","sources":["../../../src/client/hooks/use-current-menu.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,KAAK,KAAK,MAAM,aAAa,CAAC;AAC1C,eAAO,MAAM,cAAc,gFAmD1B,CAAC"}

package/client/hooks/use-current-menu.js

@@ -0,0 +1,37 @@
+import { useEffect, useState } from "react";
+import { useAdminNavigation } from "./use-admin-navigation";
+import { useWPAdmin } from "../wp-admin";
+export const useCurrentMenu = () => {
+    const wpAdmin = useWPAdmin();
+    const adminNavigation = useAdminNavigation();
+    const { wp: { globalState, wpHooks }, } = wpAdmin;
+    const pageSegment = globalState.get("page-segment");
+    const { currentPath } = useAdminNavigation();
+    const [menus, setMenus] = useState([]);
+    useEffect(() => {
+        setMenus(wpHooks.filter.apply("next_admin_menu", [], pageSegment, {
+            wpAdmin,
+            navigation: adminNavigation,
+        }));
+    }, [pageSegment]);
+    function innerFn(currentPath, menus, parentMenu) {
+        for (const menu of menus) {
+            if ((Array.isArray(menu.path) && menu.path.includes(currentPath)) ||
+                menu.path === currentPath) {
+                return [menu, parentMenu];
+            }
+            if (Array.isArray(menu.nestedMenus)) {
+                const result = innerFn(currentPath, menu.nestedMenus, menu);
+                if (result &&
+                    ((Array.isArray(result[0]?.path) &&
+                        result[0]?.path.includes(currentPath)) ||
+                        result[0]?.path === currentPath)) {
+                    return result;
+                }
+            }
+        }
+        return undefined;
+    }
+    const currentMenu = innerFn(currentPath, menus ?? []);
+    return currentMenu;
+};

package/client/hooks/use-sidebar.d.ts

@@ -0,0 +1,27 @@
+import type * as types from "../../types";
+import type * as wpCoreTypes from "@rnaga/wp-next-core/types";
+export declare const useSidebar: (props: {
+    globalState: wpCoreTypes.client.WP["globalState"];
+    viewport: {
+        isMobile: boolean;
+        isDesktop: boolean;
+    };
+}) => {
+    open: () => void;
+    close: () => void;
+    toggle: (collapsed: boolean) => void;
+    state: {
+        collapsed: boolean;
+        sticked: boolean;
+        width: number;
+        marginLeft: number;
+    };
+    setState: (state: Omit<wpCoreTypes.client.GlobalState["sidebar"], "menus">) => void;
+    px: {
+        collapsed: number;
+        open: number;
+    };
+    menus: types.client.AdminMenu[];
+    setMenus: (menus: types.client.AdminMenu[]) => void;
+};
+//# sourceMappingURL=use-sidebar.d.ts.map

package/client/hooks/use-sidebar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-sidebar.d.ts","sourceRoot":"","sources":["../../../src/client/hooks/use-sidebar.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,KAAK,KAAK,MAAM,aAAa,CAAC;AAC1C,OAAO,KAAK,KAAK,WAAW,MAAM,2BAA2B,CAAC;AAE9D,eAAO,MAAM,UAAU,GAAI,OAAO;IAChC,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC;IAClD,QAAQ,EAAE;QAAE,QAAQ,EAAE,OAAO,CAAC;QAAC,SAAS,EAAE,OAAO,CAAA;KAAE,CAAC;CACrD;;;wBA2B4B,OAAO;;;;;;;sBAkBzB,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,WAAW,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;;;;;;sBARxC,KAAK,CAAC,MAAM,CAAC,SAAS,EAAE;CAuBlD,CAAC"}

package/client/hooks/use-sidebar.js

@@ -0,0 +1,51 @@
+//import { useGlobalState } from "/use-global-state";
+export const useSidebar = (props) => {
+    const { globalState, viewport } = props;
+    const { menus, ...state } = globalState.get("sidebar");
+    const px = {
+        collapsed: viewport.isMobile || !menus || 0 === menus.length ? 0 : 60,
+        open: !menus || 0 === menus.length ? 0 : 200,
+    };
+    const open = () => globalState.set("sidebar", {
+        collapsed: false,
+        sticked: true,
+        width: px.open,
+        marginLeft: px.open,
+        menus,
+    });
+    const close = () => globalState.set("sidebar", {
+        collapsed: true,
+        sticked: false,
+        width: px.collapsed,
+        marginLeft: px.collapsed,
+        menus,
+    });
+    const toggle = (collapsed) => {
+        globalState.set("sidebar", {
+            collapsed: collapsed ? false : true,
+            sticked: state.sticked ? false : true,
+            width: collapsed ? px.open : px.collapsed,
+            marginLeft: px.collapsed,
+            menus,
+        });
+    };
+    const setMenus = (menus) => {
+        globalState.set("sidebar", {
+            ...state,
+            menus,
+        });
+    };
+    const setState = (state) => {
+        globalState.set("sidebar", { ...state, menus });
+    };
+    return {
+        open,
+        close,
+        toggle,
+        state,
+        setState,
+        px,
+        menus,
+        setMenus,
+    };
+};

package/client/hooks/use-sites.d.ts

@@ -0,0 +1,136 @@
+export declare const useSites: (props?: {
+    capabilities?: string[];
+}) => {
+    sites: {
+        user: import("@rnaga/wp-node/types").WpUsers;
+        primary_blog: Pick<NonNullable<{
+            blog_id: number;
+            site_id: number;
+            blog_roles: Record<string, {
+                name: string;
+                capabilities: string[];
+            }>;
+            blogname: string;
+            rolenames: string[];
+            capabilities: string[];
+            sitename: string;
+            siteurl: string;
+        } | {
+            capabilities: string[];
+            blog_id: number;
+            domain: string;
+            path: string;
+            site_id: number;
+            siteurl: string | undefined;
+            archived: number;
+            spam: number;
+            deleted: number;
+            rolenames: string[] | undefined;
+            blog_roles: Record<string, import("@rnaga/wp-node/types").Role>;
+            blogname: string | undefined;
+        }> & {
+            blog_id: number;
+            domain: string;
+            path: string;
+            site_id: number;
+            siteurl: string | undefined;
+            archived: number;
+            spam: number;
+            deleted: number;
+            rolenames: string[] | undefined;
+            blog_roles: Record<string, import("@rnaga/wp-node/types").Role>;
+            blogname: string | undefined;
+        }, "capabilities" | "site_id" | "blog_id" | "blogname" | "rolenames"> & {
+            blog_roles: Record<string, import("@rnaga/wp-node/types").Role> | undefined;
+        };
+        is_multisite: boolean;
+        sites: undefined | {
+            site_id: number;
+            sitename: string;
+            siteurl: string;
+            is_superadmin: boolean;
+            blogs: (Pick<NonNullable<{
+                blog_id: number;
+                site_id: number;
+                blog_roles: Record<string, {
+                    name: string;
+                    capabilities: string[];
+                }>;
+                blogname: string;
+                rolenames: string[];
+                capabilities: string[];
+                sitename: string;
+                siteurl: string;
+            } | {
+                capabilities: string[];
+                blog_id: number;
+                domain: string;
+                path: string;
+                site_id: number;
+                siteurl: string | undefined;
+                archived: number;
+                spam: number;
+                deleted: number;
+                rolenames: string[] | undefined;
+                blog_roles: Record<string, import("@rnaga/wp-node/types").Role>;
+                blogname: string | undefined;
+            }> & {
+                blog_id: number;
+                domain: string;
+                path: string;
+                site_id: number;
+                siteurl: string | undefined;
+                archived: number;
+                spam: number;
+                deleted: number;
+                rolenames: string[] | undefined;
+                blog_roles: Record<string, import("@rnaga/wp-node/types").Role>;
+                blogname: string | undefined;
+            }, "capabilities" | "site_id" | "blog_id" | "blogname" | "rolenames"> & {
+                blog_roles: Record<string, import("@rnaga/wp-node/types").Role> | undefined;
+            })[] | undefined;
+        }[];
+    };
+    blogs: (Pick<NonNullable<{
+        blog_id: number;
+        site_id: number;
+        blog_roles: Record<string, {
+            name: string;
+            capabilities: string[];
+        }>;
+        blogname: string;
+        rolenames: string[];
+        capabilities: string[];
+        sitename: string;
+        siteurl: string;
+    } | {
+        capabilities: string[];
+        blog_id: number;
+        domain: string;
+        path: string;
+        site_id: number;
+        siteurl: string | undefined;
+        archived: number;
+        spam: number;
+        deleted: number;
+        rolenames: string[] | undefined;
+        blog_roles: Record<string, import("@rnaga/wp-node/types").Role>;
+        blogname: string | undefined;
+    } | undefined> & {
+        blog_id: number;
+        domain: string;
+        path: string;
+        site_id: number;
+        siteurl: string | undefined;
+        archived: number;
+        spam: number;
+        deleted: number;
+        rolenames: string[] | undefined;
+        blog_roles: Record<string, import("@rnaga/wp-node/types").Role>;
+        blogname: string | undefined;
+    }, "capabilities" | "blog_id" | "site_id" | "blogname" | "rolenames"> & {
+        blog_roles: Record<string, import("@rnaga/wp-node/types").Role> | undefined;
+    })[] | undefined;
+    updateSites: () => Promise<boolean>;
+};
+//# sourceMappingURL=use-sites.d.ts.map

package/client/hooks/use-sites.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-sites.d.ts","sourceRoot":"","sources":["../../../src/client/hooks/use-sites.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,QAAQ,GAAI,QAAQ;IAAE,YAAY,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoD3D,CAAC"}

package/client/hooks/use-sites.js

@@ -0,0 +1,43 @@
+import { useEffect, useState } from "react";
+import { useWPAdmin } from "../wp-admin";
+import { useAdminUser } from "./use-admin-user";
+import { useAdminServerActions } from "./use-admin-server-actions";
+export const useSites = (props) => {
+    const { capabilities } = props ?? {};
+    const { wp: { globalState }, site, } = useWPAdmin();
+    const { actions, execute, safeParse } = useAdminServerActions();
+    const { adminUser } = useAdminUser();
+    const [blogs, setBlogs] = useState();
+    const updateSites = async () => {
+        const response = await execute(actions.adminUser.getAdminCurrent());
+        const result = safeParse(response);
+        if (result.success) {
+            globalState.set("adminUser", response.data);
+        }
+        return result.success;
+    };
+    useEffect(() => {
+        if (!adminUser.availableSites.primary_blog) {
+            return;
+        }
+        if (!site.isMultiSite) {
+            setBlogs([adminUser.availableSites.primary_blog]);
+            return;
+        }
+        const blogs = [];
+        for (const site of adminUser.availableSites?.sites ?? []) {
+            if (!site.blogs) {
+                continue;
+            }
+            for (const blog of site?.blogs) {
+                if (!capabilities ||
+                    capabilities.length ==
+                        blog.capabilities.filter((cap) => capabilities.includes(cap)).length) {
+                    blogs.push(blog);
+                }
+            }
+        }
+        blogs.length > 0 && setBlogs(blogs);
+    }, [adminUser.availableSites]);
+    return { sites: adminUser.availableSites, blogs, updateSites };
+};

package/client/utils/get-default-admin-hooks.d.ts

@@ -0,0 +1,3 @@
+export declare const getDefaultAdminHooks: () => (typeof import("../wp-hooks/menu-blog.hook").MenuBlogHook | typeof import("../wp-hooks/preload-modal.hook").PreloadModalHook | typeof import("../wp-hooks/themes.hook").ThemesHook)[];
+export default getDefaultAdminHooks;
+//# sourceMappingURL=get-default-admin-hooks.d.ts.map

package/client/utils/get-default-admin-hooks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-default-admin-hooks.d.ts","sourceRoot":"","sources":["../../../src/client/utils/get-default-admin-hooks.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oBAAoB,6LAAc,CAAC;AAChD,eAAe,oBAAoB,CAAC"}

package/client/utils/get-default-admin-hooks.js

@@ -0,0 +1,3 @@
+import { hooks } from "../wp-hooks";
+export const getDefaultAdminHooks = () => hooks;
+export default getDefaultAdminHooks;

package/client/utils/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./get-default-admin-hooks";
+//# sourceMappingURL=index.d.ts.map

package/client/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/client/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC"}

package/client/utils/index.js

@@ -0,0 +1 @@
+export * from "./get-default-admin-hooks";