@rnaga/wp-next-ui 1.0.1

package/SelectAutocomplete.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectAutocomplete.d.ts","sourceRoot":"","sources":["../src/SelectAutocomplete.tsx"],"names":[],"mappings":"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"}

package/SelectAutocomplete.js

@@ -0,0 +1,113 @@
+import { createElement as _createElement } from "react";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Autocomplete, ListItem, TextField, } from "@mui/material";
+import { createContext, useContext, useMemo, useState, } from "react";
+import { Typography } from "./Typography";
+const Context = createContext({});
+const sxSelectAutocomplete = (props) => {
+    const { size, sx } = props;
+    return {
+        p: "0.5px !important",
+        "& .MuiOutlinedInput-root": {
+            py: "0 !important",
+            fontSize: size == "medium" ? 14 : 12,
+            px: 1,
+            ...(sx ?? {}),
+        },
+        "& .MuiInputBase-input": {
+            cursor: "pointer",
+            height: size == "medium" ? 24 : 12,
+        },
+        "& .MuiOutlinedInput-notchedOutline": {
+            border: "none",
+        },
+        "& .MuiOutlinedInput-root .MuiAutocomplete-input": {
+            py: size == "medium" ? 0.5 : 0.3,
+        },
+        "& .MuiAutocomplete-tag": {
+            fontSize: size == "medium" ? 11 : 10,
+        },
+        //height: size == "medium" ? 32 : 24,
+        ...sx,
+    };
+};
+const SelectAutocompleteTextField = (props) => {
+    const { size, sx, params } = props;
+    return (_jsx(TextField, { ...params, size: size, sx: {
+            fontSize: size == "medium" ? 14 : 12,
+            border: (theme) => `1px solid ${theme.palette.grey[400]}`,
+            borderRadius: 1,
+            "&:focus-within": {
+                borderColor: (theme) => theme.palette.primary.main,
+            },
+            ...sx,
+        } }));
+};
+const RenderOption = (_props) => {
+    const { props, option, state, onChange, onBlur } = _props;
+    const { setItem, size, slotSxProps } = useContext(Context);
+    if (state.selected) {
+        return null;
+    }
+    return (_createElement(ListItem, { ...props, key: option.id, onClick: (e) => {
+            const item = {
+                label: option.label,
+                value: option.id,
+            };
+            onChange && onChange(`${item.value}`, item);
+            setItem(item);
+            // delegate to the original onClick
+            props?.onClick && props.onClick(e);
+        }, onBlur: (e) => {
+            onBlur &&
+                onBlur(`${option.id}`, { label: option.label, value: option.id });
+            // delegate to the original onBlur
+            props?.onBlur && props.onBlur(e);
+        } },
+        _jsx(Typography, { size: size, sx: {
+                ...slotSxProps?.options,
+            }, children: option.label })));
+};
+const Wrapper = (props) => {
+    const [item, setItem] = useState();
+    const { slotSxProps, size } = props;
+    return (_jsx(Context, { value: { item, setItem, size, slotSxProps }, children: props.children }));
+};
+export const SelectAutocomplete = (props) => {
+    const { slotProps, items, onChange, onBlur, size, value, disableClearable, sx, ...rest } = props;
+    const [item, setItem] = useState();
+    const currentValue = useMemo(() => {
+        if (!props.value) {
+            return undefined;
+        }
+        const item = items.find((item) => item.value == props.value);
+        return !item
+            ? undefined
+            : {
+                label: item.label,
+                id: `${item.value}`,
+            };
+    }, [value, items]);
+    return (_jsx(Wrapper, { ...props, children: _jsx(Autocomplete, { size: "small", value: currentValue ?? {
+                label: "",
+                id: "",
+            }, options: items.map((item) => ({
+                label: item.label,
+                id: `${item.value}`,
+            })), onBlur: () => {
+                onBlur && item && onBlur(`${item.value}`, item);
+            }, renderInput: (params) => (_jsx(SelectAutocompleteTextField, { params: params, size: size, sx: slotProps?.textField })), sx: sxSelectAutocomplete({
+                size: size ?? "small",
+                sx: slotProps?.input,
+            }), renderOption: (props, option, state) => {
+                return (_jsx(RenderOption, { props: props, option: option, state: state, onChange: onChange, onBlur: onBlur }, option.id));
+            }, disableClearable: (disableClearable === true
+                ? true
+                : value == null
+                    ? true
+                    : false), slotProps: slotProps, ...rest }) }));
+};
+SelectAutocomplete.sx = sxSelectAutocomplete;
+SelectAutocomplete.TextField = SelectAutocompleteTextField;
+SelectAutocomplete.RenderOption = RenderOption;
+SelectAutocomplete.Wrapper = Wrapper;

package/SelectMultiple.d.ts

@@ -0,0 +1,16 @@
+import { type SlotSxProps } from "./SelectAutocomplete";
+import { SyntheticEvent } from "react";
+export type SelectMultipleItem = {
+    label: string;
+    id: string;
+};
+export declare const SelectMultiple: (props: {
+    items: SelectMultipleItem[];
+    value?: SelectMultipleItem[] | string[];
+    onChange: (values: SelectMultipleItem[], e: SyntheticEvent<Element, Event>) => void;
+    freeSolo?: boolean;
+    slotSxProps?: SlotSxProps;
+    size?: "small" | "medium";
+    limitTags?: number;
+}) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=SelectMultiple.d.ts.map

package/SelectMultiple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectMultiple.d.ts","sourceRoot":"","sources":["../src/SelectMultiple.tsx"],"names":[],"mappings":"AAIA,OAAO,EAAsB,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAC5E,OAAO,EAAE,cAAc,EAAW,MAAM,OAAO,CAAC;AAMhD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,OAAO;IACpC,KAAK,EAAE,kBAAkB,EAAE,CAAC;IAC5B,KAAK,CAAC,EAAE,kBAAkB,EAAE,GAAG,MAAM,EAAE,CAAC;IACxC,QAAQ,EAAE,CACR,MAAM,EAAE,kBAAkB,EAAE,EAC5B,CAAC,EAAE,cAAc,CAAC,OAAO,EAAE,KAAK,CAAC,KAC9B,IAAI,CAAC;IACV,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,IAAI,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;IAC1B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,4CA8DA,CAAC"}

package/SelectMultiple.js

@@ -0,0 +1,28 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Autocomplete } from "@mui/material";
+import { SelectAutocomplete } from "./SelectAutocomplete";
+import { useMemo } from "react";
+const sxSelectAutocomplete = SelectAutocomplete.sx;
+const SelectAutocompleteTextField = SelectAutocomplete.TextField;
+const RenderOption = SelectAutocomplete.RenderOption;
+export const SelectMultiple = (props) => {
+    const { items, onChange, freeSolo = true, slotSxProps, size, limitTags = 2, } = props;
+    const value = useMemo(() => (props.value ?? []).map((item) => typeof item === "string" ? { label: item, id: item } : item), [props.value]);
+    return (_jsx(SelectAutocomplete.Wrapper, { size: size, slotSxProps: slotSxProps, children: _jsx(Autocomplete, { size: "small", multiple: true, limitTags: limitTags, options: items.map((item) => ({
+                label: item.label,
+                id: `${item.id}`,
+            })), value: value, onChange: (event, value) => {
+                onChange(value, event);
+            }, sx: sxSelectAutocomplete({
+                size: size ?? "small",
+                sx: { ...slotSxProps?.input },
+            }), renderInput: (params) => (_jsx(SelectAutocompleteTextField, { params: params, size: size, sx: slotSxProps?.textField })), renderOption: (props, option, state) => {
+                const id = typeof option === "string" ? option : option.id;
+                const label = typeof option === "string" ? option : option.label;
+                return (_jsx(RenderOption, { props: props, option: {
+                        id,
+                        label,
+                    }, state: state }, id));
+            } }) }));
+};

package/SelectWPPost.d.ts

@@ -0,0 +1,17 @@
+import type * as wpTypes from "@rnaga/wp-node/types";
+import type * as wpCoreTypes from "@rnaga/wp-next-core/types";
+import { type SlotSxProps } from "./SelectAutocomplete";
+type FreeSolo = true | false;
+type Value<T extends FreeSolo> = T extends true ? Pick<wpCoreTypes.actions.Posts[number], "ID" | "post_title"> : wpCoreTypes.actions.Posts[number];
+export declare const SelectWPPost: <T extends FreeSolo = false>(props: {
+    onChange: (post: Value<T>) => any;
+    defaultValue?: number;
+    postArgs?: wpTypes.crud.CrudParameters<"post", "list">[0];
+    postOptions?: wpTypes.crud.CrudParameters<"post", "list">[1];
+    size?: "small" | "medium";
+    slotSxProps?: SlotSxProps;
+    freeSolo?: T;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const SelectFreeSoloWPPost: (props: Parameters<typeof SelectWPPost<true>>[0]) => import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=SelectWPPost.d.ts.map

package/SelectWPPost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectWPPost.d.ts","sourceRoot":"","sources":["../src/SelectWPPost.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,KAAK,OAAO,MAAM,sBAAsB,CAAC;AAErD,OAAO,KAAK,KAAK,WAAW,MAAM,2BAA2B,CAAC;AAG9D,OAAO,EAAsB,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAM5E,KAAK,QAAQ,GAAG,IAAI,GAAG,KAAK,CAAC;AAE7B,KAAK,KAAK,CAAC,CAAC,SAAS,QAAQ,IAAI,CAAC,SAAS,IAAI,GAC3C,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,IAAI,GAAG,YAAY,CAAC,GAC5D,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;AAEtC,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,QAAQ,GAAG,KAAK,EAAE,OAAO;IAC9D,QAAQ,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC;IAClC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1D,WAAW,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7D,IAAI,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;IAC1B,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,QAAQ,CAAC,EAAE,CAAC,CAAC;CACd,4CAkJA,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,OAAO,UAAU,CAAC,OAAO,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,4CAIhD,CAAC"}

package/SelectWPPost.js

@@ -0,0 +1,98 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Autocomplete } from "@mui/material";
+import { useServerActions } from "@rnaga/wp-next-core/client/hooks/use-server-actions";
+import { Typography } from "./Typography";
+import { SelectAutocomplete } from "./SelectAutocomplete";
+const sxSelectAutocomplete = SelectAutocomplete.sx;
+const SelectAutocompleteTextField = SelectAutocomplete.TextField;
+const RenderOption = SelectAutocomplete.RenderOption;
+export const SelectWPPost = (props) => {
+    const { onChange, defaultValue, postOptions, postArgs, slotSxProps, size, freeSolo = false, } = props;
+    const { actions, parse, safeParse } = useServerActions();
+    const [posts, setPosts] = useState();
+    const [currentPost, setCurrentPost] = useState();
+    const postTypes = postOptions?.postTypes ?? ["post"];
+    useEffect(() => {
+        (async () => {
+            let currentPost;
+            if (defaultValue) {
+                [currentPost] = ((await actions.post
+                    .list({ include: [defaultValue], per_page: 1, ...postArgs }, { postTypes, ...postOptions })
+                    .then(parse)) ?? [])[0];
+                setCurrentPost(currentPost);
+            }
+            const [posts] = await actions.post
+                .list({
+                exclude: defaultValue ? [defaultValue] : undefined,
+                ...postArgs,
+            }, { postTypes, ...postOptions })
+                .then(parse);
+            setPosts(currentPost ? [...posts, currentPost] : posts);
+        })();
+    }, []);
+    const handleSearch = async (value) => {
+        const response = await actions.post
+            .list({
+            search: value,
+            ...postArgs,
+        }, { postTypes, ...postOptions })
+            .then(safeParse);
+        if (!response.success) {
+            return;
+        }
+        setPosts(currentPost ? [...response.data, currentPost] : response.data);
+    };
+    const arePostsEqual = (a, b) => {
+        return a.ID === b.ID;
+    };
+    const getPostKey = (post) => `${Math.random()}-${post.ID}`;
+    if (!posts || (defaultValue && !currentPost)) {
+        return _jsx(Typography, { children: "Loading.." });
+    }
+    let value = currentPost;
+    if (freeSolo && !currentPost) {
+        value = {
+            ID: 0,
+            post_title: "",
+        };
+    }
+    return (_jsx(SelectAutocomplete.Wrapper, { size: size, slotSxProps: slotSxProps, children: _jsx(Autocomplete, { size: "small", freeSolo: freeSolo, disableClearable: true, value: value, onChange: (e, v) => {
+                const post = v;
+                console.log("onChange", v);
+                setCurrentPost(post);
+                onChange(post);
+            }, onInputChange: (event, value, reason) => {
+                if (freeSolo && typeof value === "string") {
+                    const newValue = {
+                        ID: 0,
+                        post_title: value,
+                    };
+                    onChange(newValue);
+                    setCurrentPost(newValue);
+                }
+                if (reason === "input") {
+                    handleSearch(value);
+                }
+            }, getOptionKey: getPostKey, getOptionLabel: (option) => {
+                if (freeSolo && typeof option === "string") {
+                    return option;
+                }
+                return typeof option !== "string" ? option.post_title : "";
+            }, 
+            // getOptionLabel={(option) => option.post_title}
+            isOptionEqualToValue: arePostsEqual, options: [...posts], renderInput: (params) => (_jsx(SelectAutocompleteTextField, { params: params, size: size, sx: slotSxProps?.textField })), sx: sxSelectAutocomplete({
+                size: size ?? "small",
+                sx: slotSxProps?.input,
+            }), renderOption: (props, option, state) => {
+                const postId = option.ID;
+                return (_jsx(RenderOption, { props: props, option: {
+                        label: option.post_title,
+                        id: `${postId}`,
+                    }, state: state }, postId));
+            } }, `post-${defaultValue ?? 0}`) }));
+};
+export const SelectFreeSoloWPPost = (props) => {
+    const { freeSolo, ...rest } = props;
+    return _jsx(SelectWPPost, { ...rest, freeSolo: true });
+};

package/SelectWPTaxonomy.d.ts

@@ -0,0 +1,9 @@
+import * as wpTypes from "@rnaga/wp-node/types";
+import type * as wpCoreTypes from "@rnaga/wp-next-core/types";
+export declare const SelectWPTaxonomy: (props: {
+    onClick: (taxonomy: wpCoreTypes.actions.Taxonomies[number]) => any;
+    onInit: (taxonomy: wpCoreTypes.actions.Taxonomies[number]) => any;
+    defaultValue: wpTypes.TaxonomyName;
+    size?: "small" | "medium";
+}) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=SelectWPTaxonomy.d.ts.map

package/SelectWPTaxonomy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectWPTaxonomy.d.ts","sourceRoot":"","sources":["../src/SelectWPTaxonomy.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,OAAO,MAAM,sBAAsB,CAAC;AAIhD,OAAO,KAAK,KAAK,WAAW,MAAM,2BAA2B,CAAC;AAK9D,eAAO,MAAM,gBAAgB,GAAI,OAAO;IACtC,OAAO,EAAE,CAAC,QAAQ,EAAE,WAAW,CAAC,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,GAAG,CAAC;IACnE,MAAM,EAAE,CAAC,QAAQ,EAAE,WAAW,CAAC,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,GAAG,CAAC;IAClE,YAAY,EAAE,OAAO,CAAC,YAAY,CAAC;IACnC,IAAI,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;CAC3B,4CA6CA,CAAC"}

package/SelectWPTaxonomy.js

@@ -0,0 +1,35 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { useServerActions } from "@rnaga/wp-next-core/client/hooks/use-server-actions";
+import { Select } from "./Select";
+import { Typography } from "./Typography";
+export const SelectWPTaxonomy = (props) => {
+    const { onClick, onInit, defaultValue, size } = props;
+    const { actions, parse } = useServerActions();
+    const [taxonomies, setTaxonomies] = useState();
+    useEffect(() => {
+        actions.term.taxonomies().then((response) => {
+            const [taxonomies] = parse(response);
+            setTaxonomies(taxonomies);
+            const defaultTaxonomy = taxonomies.find((taxonomy) => taxonomy.name == defaultValue);
+            defaultTaxonomy && onInit(defaultTaxonomy);
+        });
+    }, []);
+    if (!taxonomies) {
+        return _jsx(Typography, { children: "Loading..." });
+    }
+    return (_jsx(Select, { size: size, enum: taxonomies.map((taxonomy) => {
+            return {
+                label: taxonomy.name,
+                value: taxonomy.name,
+            };
+        }), value: defaultValue, onChange: (value) => {
+            console.log("Selected syntax:", value);
+            const index = taxonomies.findIndex((taxonomy) => taxonomy.name === value);
+            if (index === -1) {
+                console.error("Selected taxonomy not found:", value);
+                return;
+            }
+            onClick(taxonomies[index]);
+        } }));
+};

package/SelectWPTerm.d.ts

@@ -0,0 +1,13 @@
+import type * as wpCoreTypes from "@rnaga/wp-next-core/types";
+import { type SlotSxProps } from "./SelectAutocomplete";
+type FreeSolo = true | false;
+type Value = Pick<wpCoreTypes.actions.Terms[number], "term_id" | "name">;
+export declare const SelectWPTerm: <T extends FreeSolo = false>(props: {
+    taxonomy: wpCoreTypes.actions.Taxonomies[number]["name"];
+    onChange: (term: Value) => any;
+    defaultValue?: number;
+    size?: "small" | "medium";
+    slotSxProps?: SlotSxProps;
+}) => import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=SelectWPTerm.d.ts.map

package/SelectWPTerm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectWPTerm.d.ts","sourceRoot":"","sources":["../src/SelectWPTerm.tsx"],"names":[],"mappings":"AAOA,OAAO,KAAK,KAAK,WAAW,MAAM,2BAA2B,CAAC;AAG9D,OAAO,EAAsB,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAM5E,KAAK,QAAQ,GAAG,IAAI,GAAG,KAAK,CAAC;AAE7B,KAAK,KAAK,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,SAAS,GAAG,MAAM,CAAC,CAAC;AAEzE,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,QAAQ,GAAG,KAAK,EAAE,OAAO;IAC9D,QAAQ,EAAE,WAAW,CAAC,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;IACzD,QAAQ,EAAE,CAAC,IAAI,EAAE,KAAK,KAAK,GAAG,CAAC;IAC/B,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,IAAI,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;IAC1B,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B,4CA+HA,CAAC"}

package/SelectWPTerm.js

@@ -0,0 +1,92 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useState } from "react";
+import { Autocomplete } from "@mui/material";
+import { useServerActions } from "@rnaga/wp-next-core/client/hooks/use-server-actions";
+import { Typography } from "./Typography";
+import { SelectAutocomplete } from "./SelectAutocomplete";
+const sxSelectAutocomplete = SelectAutocomplete.sx;
+const SelectAutocompleteTextField = SelectAutocomplete.TextField;
+const RenderOption = SelectAutocomplete.RenderOption;
+export const SelectWPTerm = (props) => {
+    const { taxonomy, onChange, defaultValue, slotSxProps, size } = props;
+    const { actions, parse, safeParse } = useServerActions();
+    const [terms, setTerms] = useState();
+    const [currentTerm, setCurrentTerm] = useState();
+    useEffect(() => {
+        (async () => {
+            let currentTerm;
+            if (defaultValue) {
+                [currentTerm] = ((await actions.term
+                    .list(taxonomy, { include: [defaultValue], per_page: 1 })
+                    .then(parse)) ?? [])[0];
+                setCurrentTerm(currentTerm);
+            }
+            const [terms] = await actions.term
+                .list(taxonomy, {
+                exclude: defaultValue ? [defaultValue] : undefined,
+            })
+                .then(parse);
+            setTerms(currentTerm ? [...terms, currentTerm] : terms);
+        })();
+    }, []);
+    const handleSearch = async (value) => {
+        const response = await actions.term
+            .list(taxonomy, {
+            search: value,
+        })
+            .then(safeParse);
+        if (!response.success) {
+            return;
+        }
+        setTerms(response.data);
+    };
+    const areTermsEqual = (a, b) => {
+        return a.term_id === b.term_id;
+    };
+    const getTermKey = (term) => `${Math.random()}-${term.term_id}`;
+    if (!terms || (defaultValue && !currentTerm)) {
+        return _jsx(Typography, { children: "Loading.." });
+    }
+    let value = currentTerm;
+    if (!currentTerm) {
+        value = {
+            term_id: 0,
+            name: "",
+        };
+    }
+    console.log("SelectWPTerm value", value, defaultValue);
+    return (_jsx(SelectAutocomplete.Wrapper, { size: size, slotSxProps: slotSxProps, children: _jsx(Autocomplete, { size: "small", disableClearable: true, value: value, onChange: (e, v) => {
+                const term = v;
+                console.log("onChange", v);
+                setCurrentTerm(term);
+                onChange(term);
+            }, onInputChange: (event, value, reason) => {
+                if (typeof value === "string") {
+                    const newValue = {
+                        term_id: 0,
+                        name: value,
+                    };
+                    onChange(newValue);
+                    setCurrentTerm(newValue);
+                }
+                if (reason === "input") {
+                    handleSearch(value);
+                }
+            }, getOptionKey: getTermKey, getOptionLabel: (option) => {
+                if (typeof option === "string") {
+                    return option;
+                }
+                return typeof option !== "string" ? option.name : "";
+            }, 
+            // getOptionLabel={(option) => option.name}
+            isOptionEqualToValue: areTermsEqual, options: [...terms], renderInput: (params) => (_jsx(SelectAutocompleteTextField, { params: params, size: size, sx: slotSxProps?.textField })), sx: sxSelectAutocomplete({
+                size: size ?? "small",
+                sx: slotSxProps?.input,
+            }), renderOption: (props, option, state) => {
+                const termId = option.term_id;
+                return (_jsx(RenderOption, { props: props, option: {
+                        label: option.name,
+                        id: `${termId}`,
+                    }, state: state }, termId));
+            } }, `post-${defaultValue ?? 0}`) }));
+};

package/SelectWPTerms.d.ts

@@ -0,0 +1,27 @@
+import type * as wpCoreTypes from "@rnaga/wp-next-core/types";
+import { type SlotSxProps } from "./SelectAutocomplete";
+export declare const SelectWPTerms: (props: {
+    taxonomy: wpCoreTypes.actions.Taxonomies[number]["name"];
+    defaultValues?: number[];
+    excludeIds?: number[];
+    onChange: (values: Array<number | string>) => void;
+    freeSolo?: boolean;
+    slotSxProps?: SlotSxProps;
+    size?: "small" | "medium";
+    multiple?: boolean;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const SelectWPCategories: (props: {
+    onChange: (value: (string | number)[]) => void;
+    value: string | number[];
+    size?: "small" | "medium";
+    slotSxProps?: SlotSxProps;
+    freeSolo?: boolean;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const SelectWPTags: (props: {
+    onChange: (value: (string | number)[]) => void;
+    value: string | number[];
+    size?: "small" | "medium";
+    slotSxProps?: SlotSxProps;
+    freeSolo?: boolean;
+}) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=SelectWPTerms.d.ts.map

package/SelectWPTerms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectWPTerms.d.ts","sourceRoot":"","sources":["../src/SelectWPTerms.tsx"],"names":[],"mappings":"AAQA,OAAO,KAAK,KAAK,WAAW,MAAM,2BAA2B,CAAC;AAE9D,OAAO,EAAsB,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAa5E,eAAO,MAAM,aAAa,GAAI,OAAO;IACnC,QAAQ,EAAE,WAAW,CAAC,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC;IACzD,aAAa,CAAC,EAAE,MAAM,EAAE,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,KAAK,IAAI,CAAC;IACnD,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,IAAI,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;IAC1B,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,4CAiJA,CAAC;AAsCF,eAAO,MAAM,kBAAkB,UA9BnB;IACN,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,KAAK,IAAI,CAAC;IAC/C,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACzB,IAAI,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;IAC1B,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,4CAwB4D,CAAC;AAClE,eAAO,MAAM,YAAY,UA/Bb;IACN,QAAQ,EAAE,CAAC,KAAK,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,KAAK,IAAI,CAAC;IAC/C,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAAC;IACzB,IAAI,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;IAC1B,WAAW,CAAC,EAAE,WAAW,CAAC;IAC1B,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,4CAyBsD,CAAC"}

package/SelectWPTerms.js

@@ -0,0 +1,105 @@
+"use client";
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+import { Autocomplete, Chip } from "@mui/material";
+import { useServerActions } from "@rnaga/wp-next-core/client/hooks/use-server-actions";
+import { flat as flatHierarchy } from "@rnaga/wp-node/common/hierarchy";
+import { SelectAutocomplete } from "./SelectAutocomplete";
+const sxSelectAutocomplete = SelectAutocomplete.sx;
+const SelectAutocompleteTextField = SelectAutocomplete.TextField;
+const RenderOption = SelectAutocomplete.RenderOption;
+export const SelectWPTerms = (props) => {
+    const { taxonomy, defaultValues = [], onChange, freeSolo = true, slotSxProps, excludeIds, size, } = props;
+    const { actions, safeParse, parse } = useServerActions();
+    const initialValues = useRef(defaultValues);
+    const [terms, setTerms] = useState([]);
+    const [defaultTerms, setDefaultTerms] = useState();
+    useEffect(() => {
+        const defaultTermIds = defaultValues.filter((id) => typeof id === "number");
+        let defaultTerms = [];
+        (async () => {
+            if (defaultTermIds.length > 0) {
+                [defaultTerms] = await actions.term
+                    .list(taxonomy, { include: defaultTermIds })
+                    .then(parse);
+                setDefaultTerms(defaultTerms);
+            }
+            const [terms] = await actions.term
+                .list(taxonomy, {
+                exclude: [defaultTermIds, ...(excludeIds || [])].flat(),
+            })
+                .then(parse);
+            const termHierarchy = flatHierarchy("terms", [...terms, ...defaultTerms]);
+            setTerms(termHierarchy);
+        })();
+    }, []);
+    const handleSearch = (value) => {
+        const termOptions = terms.filter((term) => typeof term !== "string");
+        const termStrings = terms.filter((term) => typeof term === "string");
+        const termIds = termOptions.map((term) => term.term_id);
+        actions.term
+            .list(taxonomy, {
+            search: value.length > 0 ? value : undefined,
+            exclude: [termIds, ...(excludeIds || [])].flat(),
+        })
+            .then((response) => {
+            const result = safeParse(response);
+            if (!result.success) {
+                return;
+            }
+            const termHierarchy = flatHierarchy("terms", [
+                ...result.data,
+                ...termOptions,
+            ]);
+            setTerms([...termHierarchy, ...termStrings]);
+        });
+    };
+    const getTermLabel = (term) => typeof term === "string"
+        ? term
+        : `${Array(term.depth).fill("-").join("")} ${term.name}`;
+    if (!terms || (initialValues.current.length > 0 && !defaultTerms)) {
+        return _jsx(_Fragment, { children: "Loading.." });
+    }
+    return (_jsx(SelectAutocomplete.Wrapper, { size: size, slotSxProps: slotSxProps, children: _jsx(Autocomplete, { size: "small", multiple: true, limitTags: 2, options: terms, defaultValue: defaultTerms, freeSolo: freeSolo, renderValue: (value, getItemProps) => {
+                return value.map((option, index) => {
+                    const { key, ...props } = getItemProps({ index });
+                    const label = typeof option === "string" ? option : option.name;
+                    const chipKey = typeof option === "string" ? option : option.term_id;
+                    return (_jsx(Chip, { label: label, ...props, sx: slotSxProps?.chip }, `${Math.random()}-${chipKey}`));
+                });
+            }, getOptionLabel: getTermLabel, isOptionEqualToValue: (term1, term2) => typeof term1 !== "string" &&
+                typeof term2 !== "string" &&
+                term1?.term_id === term2?.term_id, onInputChange: (event, value, reason) => {
+                reason === "input" && handleSearch(value);
+            }, onChange: (event, value) => {
+                onChange(value.map((v) => (typeof v === "string" ? v : v.term_id)));
+            }, sx: sxSelectAutocomplete({
+                size: size ?? "small",
+                sx: { ...slotSxProps?.input, height: "auto" },
+            }), renderInput: (params) => (_jsx(SelectAutocompleteTextField, { params: params, size: size, sx: slotSxProps?.textField })), renderOption: (props, option, state) => {
+                const termId = typeof option === "string" ? option : option.term_id;
+                return (_jsx(RenderOption, { props: props, option: {
+                        label: getTermLabel(option),
+                        id: `${termId}`,
+                    }, state: state }, termId));
+            } }, `multiple-terms-${taxonomy}`) }));
+};
+const SelectMultipleTerms = 
+// eslint-disable-next-line react/display-name
+(taxonomy) => 
+// eslint-disable-next-line react/display-name
+(props) => {
+    return (_jsx(SelectWPTerms, { size: props.size, taxonomy: taxonomy, defaultValues: !props.value
+            ? []
+            : Array.isArray(props.value)
+                ? props.value
+                : // If value is a string, split it by comma and convert to numbers
+                    props.value
+                        ?.split(",")
+                        .map((v) => parseInt(v)), onChange: (values) => {
+            props.onChange(values);
+            //props.onChange(values.join(","));
+        }, freeSolo: props.freeSolo ?? false }));
+};
+export const SelectWPCategories = SelectMultipleTerms("category");
+export const SelectWPTags = SelectMultipleTerms("post_tag");

package/SelectWPUser.d.ts

@@ -0,0 +1,16 @@
+import type * as wpTypes from "@rnaga/wp-node/types";
+import type * as wpCoreTypes from "@rnaga/wp-next-core/types";
+import { type SlotSxProps } from "./SelectAutocomplete";
+type FreeSolo = true | false;
+type Value<T extends FreeSolo> = T extends true ? Pick<wpCoreTypes.actions.Users[number], "ID" | "user_nicename"> : wpCoreTypes.actions.Users[number];
+export declare const SelectWPUser: <T extends FreeSolo = false>(props: {
+    onChange: (user: Value<T>) => any;
+    defaultValue?: number;
+    blogId: number;
+    userArgs?: wpTypes.crud.CrudParameters<"user", "list">[0];
+    userOptions?: wpTypes.crud.CrudParameters<"user", "list">[1];
+    size?: "small" | "medium";
+    slotSxProps?: SlotSxProps;
+}) => import("react/jsx-runtime").JSX.Element;
+export {};
+//# sourceMappingURL=SelectWPUser.d.ts.map

package/SelectWPUser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SelectWPUser.d.ts","sourceRoot":"","sources":["../src/SelectWPUser.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,KAAK,OAAO,MAAM,sBAAsB,CAAC;AAErD,OAAO,KAAK,KAAK,WAAW,MAAM,2BAA2B,CAAC;AAG9D,OAAO,EAAsB,KAAK,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAM5E,KAAK,QAAQ,GAAG,IAAI,GAAG,KAAK,CAAC;AAE7B,KAAK,KAAK,CAAC,CAAC,SAAS,QAAQ,IAAI,CAAC,SAAS,IAAI,GAC3C,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE,IAAI,GAAG,eAAe,CAAC,GAC/D,WAAW,CAAC,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;AActC,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,QAAQ,GAAG,KAAK,EAAE,OAAO;IAC9D,QAAQ,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,GAAG,CAAC;IAClC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1D,WAAW,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;IAC7D,IAAI,CAAC,EAAE,OAAO,GAAG,QAAQ,CAAC;IAC1B,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B,4CA2IA,CAAC"}