@creopse/react 0.0.7 → 0.0.9

package/dist/hooks/index.mjs

@@ -0,0 +1,439 @@
+import { P as PropsContext, b as useApi, u as useHelper, a as ResolveSectionsContext, c as cloneDeep } from "../index-DAEkiy4W.js";
+import { d } from "../index-DAEkiy4W.js";
+import { useContext, useState, useEffect, useCallback, useMemo } from "react";
+import { usePage } from "@inertiajs/react";
+const useProps = () => {
+  const manager = useContext(PropsContext);
+  if (!manager) {
+    throw new Error("[@creopse/react] CreopseProvider not found in tree");
+  }
+  const [props, setProps] = useState(manager.getState().props);
+  useEffect(() => {
+    const unsubscribe = manager.subscribe((newProps) => {
+      setProps(newProps);
+    });
+    return unsubscribe;
+  }, [manager]);
+  return props;
+};
+const useContent = () => {
+  const { request } = useApi();
+  const { fileUrl } = useHelper();
+  const page = usePage();
+  const resolveSections = useContext(ResolveSectionsContext);
+  const getProps = useCallback(
+    () => page.props,
+    [page.props]
+  );
+  const pageData = useMemo(
+    () => page.props.pageData,
+    [page.props.pageData]
+  );
+  const newsArticle = useMemo(
+    () => page.props.article,
+    [page.props.article]
+  );
+  const newsCategory = useMemo(
+    () => page.props.category,
+    [page.props.category]
+  );
+  const newsTag = useMemo(
+    () => page.props.tag,
+    [page.props.tag]
+  );
+  const contentModelItem = useMemo(
+    () => page.props.contentModelItem,
+    [page.props.contentModelItem]
+  );
+  const getSectionData = useCallback(
+    (key) => {
+      if (!key) return null;
+      const keyParts = key.split("__");
+      const slug = keyParts.length ? keyParts[0] : "";
+      const linkId = keyParts.length > 1 ? keyParts[1] : "";
+      return page.props.pageData?.sections?.find(
+        (section) => section.slug === slug && section.pivot?.linkId === linkId
+      )?.pivot?.data || null;
+    },
+    [page.props.pageData?.sections]
+  );
+  const getSectionRootData = useCallback(
+    (key) => getSectionData(key)?.index,
+    [getSectionData]
+  );
+  const getSectionSettings = useCallback(
+    (key) => {
+      if (!key) return null;
+      const keyParts = key.split("__");
+      const slug = keyParts.length ? keyParts[0] : "";
+      const linkId = keyParts.length > 1 ? keyParts[1] : "";
+      return page.props.pageData?.sections?.find(
+        (section) => section.slug === slug && section.pivot?.linkId === linkId
+      )?.pivot?.settings || null;
+    },
+    [page.props.pageData?.sections]
+  );
+  const getSectionSettingsGroup = useCallback(
+    (key, group) => {
+      const settings = getSectionSettings(key);
+      return settings?.[group];
+    },
+    [getSectionSettings]
+  );
+  const getSectionSetting = useCallback(
+    (key, group, name) => {
+      const settings = getSectionSettingsGroup(key, group);
+      return settings?.[name];
+    },
+    [getSectionSettingsGroup]
+  );
+  const getSectionsInOrder = useCallback(() => {
+    const sections = pageData?.sections;
+    const sectionsOrder = pageData?.sectionsOrder;
+    const sectionsOrdered = [];
+    if (Array.isArray(sections) && Array.isArray(sectionsOrder)) {
+      for (const section of sectionsOrder) {
+        if (section) {
+          const item = sections.find(
+            (value) => `${value.slug}__${value.pivot?.linkId}` === section
+          );
+          if (item) {
+            sectionsOrdered.push(item);
+          }
+        }
+      }
+    }
+    return sectionsOrdered.length ? sectionsOrdered : sections || [];
+  }, [pageData?.sections, pageData?.sectionsOrder]);
+  const getFinalPageSections = useCallback(() => {
+    const sections = getSectionsInOrder();
+    const sectionsDisabled = pageData?.sectionsDisabled;
+    return sections.filter((section) => {
+      return !sectionsDisabled?.includes(
+        `${section.slug}__${section.pivot?.linkId}`
+      );
+    });
+  }, [getSectionsInOrder, pageData?.sectionsDisabled]);
+  const getAnySectionData = useCallback(
+    async (sectionSlug, pageSlug, linkId = "default") => {
+      const task = await request({
+        url: `section-data/${sectionSlug}/source/${pageSlug}/link/${linkId}`
+      });
+      if (task.success && task.result) {
+        return task.result.data;
+      }
+      return null;
+    },
+    [request]
+  );
+  const getComponents = useCallback(() => {
+    const components = {};
+    if (!resolveSections) {
+      throw new Error("[@creopse/react] resolveSections is required");
+    }
+    const files = resolveSections();
+    for (const [key, value] of Object.entries(files)) {
+      const componentName = key.replace(/^\.\/(.*)\.\w+$/, "$1");
+      const parts = componentName.split("/");
+      const name = parts[parts.length - 1]?.split(".")[0];
+      components[name] = value.default;
+    }
+    return components;
+  }, [resolveSections]);
+  const getContentModel = useCallback(
+    (name) => {
+      return page.props?.contentModels?.find(
+        (contentModel) => contentModel.name === name
+      );
+    },
+    [page.props?.contentModels]
+  );
+  const formatContentModelItemData = useCallback(
+    (item) => {
+      const { index: _, ...rest } = item.contentModelData;
+      return {
+        ...item,
+        data: {
+          ...item.contentModelData?.index,
+          ...rest
+        }
+      };
+    },
+    []
+  );
+  const getContentModelItems = useCallback(
+    async (name, filterByIsActive = true) => {
+      const task = await request({
+        url: `content-model/items?contentModelName=${name}${filterByIsActive ? "&isActive=true" : ""}`
+      });
+      if (task.success && task.result) {
+        return (task.result.data || []).map(
+          (item) => formatContentModelItemData(item)
+        );
+      }
+      return [];
+    },
+    [request, formatContentModelItemData]
+  );
+  const getPaginatedContentModelItems = useCallback(
+    async (name, pageSize, filterByIsActive = true) => {
+      const task = await request({
+        url: `content-model/items?pageSize=${pageSize}&contentModelName=${name}${filterByIsActive ? "&isActive=true" : ""}`
+      });
+      if (task.success && task.result) {
+        const items = (task.result.data?.items || []).map(
+          (item) => formatContentModelItemData(item)
+        );
+        const total = task.result.data?.meta?.total || 0;
+        const currentPage = task.result.data?.meta?.currentPage || 1;
+        return {
+          items,
+          total,
+          currentPage
+        };
+      }
+      return {
+        items: [],
+        total: 0,
+        currentPage: 1
+      };
+    },
+    [request, formatContentModelItemData]
+  );
+  const getMenu = useCallback(
+    (name, filterByIsActive = true) => {
+      const menu = page.props?.menus?.find((menu2) => menu2.name === name);
+      if (menu) {
+        menu.items = cloneDeep(
+          menu.items?.filter((item) => !filterByIsActive || item.isActive)?.sort((a, b) => a.position - b.position)
+        );
+      }
+      return menu;
+    },
+    [page.props?.menus]
+  );
+  const getMenuByLocation = useCallback(
+    (name, filterByIsActive = true) => {
+      const menu = page.props?.menus?.find(
+        (menu2) => menu2.location?.name === name
+      );
+      if (menu) {
+        menu.items = cloneDeep(
+          menu.items?.filter((item) => !filterByIsActive || item.isActive)?.sort((a, b) => a.position - b.position)
+        );
+      }
+      return menu;
+    },
+    [page.props?.menus]
+  );
+  const getMenuItems = useCallback(
+    (name, filterByIsVisible = true) => {
+      return getMenu(name)?.items?.filter((item) => !filterByIsVisible || item.isVisible)?.sort((a, b) => a.position - b.position);
+    },
+    [getMenu]
+  );
+  const getMenuItemById = useCallback(
+    (id) => {
+      const menuItems = [];
+      const menus = page.props?.menus || [];
+      menus.forEach((menu) => {
+        if (Array.isArray(menu.items)) menuItems.push(...menu.items);
+      });
+      return menuItems.find((item) => item.id === id);
+    },
+    [page.props?.menus]
+  );
+  const getMenuItemsByLocation = useCallback(
+    (name, filterByIsVisible = true) => {
+      return getMenuByLocation(name)?.items?.filter((item) => !filterByIsVisible || item.isVisible)?.sort((a, b) => a.position - b.position);
+    },
+    [getMenuByLocation]
+  );
+  const getMenuGroups = useCallback(
+    (name, byLocation = false, filterByIsVisible = true) => {
+      const groups = [];
+      const items = byLocation ? getMenuItemsByLocation(name, filterByIsVisible) : getMenuItems(name, filterByIsVisible);
+      if (items) {
+        for (const item of items) {
+          const groupAlreadyExists = groups.find(
+            (group) => group.id === item.menuItemGroupId
+          );
+          if (!groupAlreadyExists) {
+            const group = page.props?.menuItemGroups?.find(
+              (group2) => group2.id === item.menuItemGroupId
+            );
+            if (group) groups.push(group);
+          }
+        }
+      }
+      return groups;
+    },
+    [getMenuItems, getMenuItemsByLocation, page.props?.menuItemGroups]
+  );
+  const getMenuItemsByGroup = useCallback(
+    (name, groupId, byLocation = false, filterByIsVisible = true) => {
+      const items = byLocation ? getMenuItemsByLocation(name, filterByIsVisible) : getMenuItems(name, filterByIsVisible);
+      return items?.filter((item) => item.menuItemGroupId === groupId);
+    },
+    [getMenuItems, getMenuItemsByLocation]
+  );
+  const getMenuGroupedItems = useCallback(
+    (name, byLocation = false, filterByIsVisible = true) => {
+      const groups = getMenuGroups(name, byLocation);
+      return groups.map((group) => ({
+        group,
+        items: getMenuItemsByGroup(
+          name,
+          group.id || 0,
+          byLocation,
+          filterByIsVisible
+        )
+      }));
+    },
+    [getMenuGroups, getMenuItemsByGroup]
+  );
+  const getMenuUngroupedItems = useCallback(
+    (name, byLocation = false, filterByIsVisible = true) => {
+      const items = byLocation ? getMenuItemsByLocation(name, filterByIsVisible) : getMenuItems(name, filterByIsVisible);
+      return items?.filter((item) => !item.menuItemGroupId);
+    },
+    [getMenuItems, getMenuItemsByLocation]
+  );
+  const getAppInformationValue = useCallback(
+    (key, type = "string") => {
+      const appInformation = page.props.appInformation;
+      const setting = appInformation.find((s) => s.key === key);
+      let value = "";
+      switch (type) {
+        case "number":
+          value = setting && parseInt(setting.value) && !isNaN(parseInt(setting.value)) ? parseInt(setting.value) : 0;
+          break;
+        case "boolean":
+          value = setting && !isNaN(parseInt(setting.value)) && parseInt(setting.value) > 0;
+          break;
+        case "object":
+          value = setting && setting.value ? JSON.parse(setting.value) : {};
+          break;
+        case "array":
+          value = setting && setting.value ? JSON.parse(setting.value) : [];
+          break;
+        default:
+          value = setting && setting.value ? setting.value : "";
+          break;
+      }
+      return value;
+    },
+    [page.props.appInformation]
+  );
+  const appPrimaryColor = useMemo(() => {
+    const primaryColor = getAppInformationValue(
+      "primaryColor"
+    );
+    return primaryColor || "#005B97";
+  }, [getAppInformationValue]);
+  const appSecondaryColor = useMemo(() => {
+    const secondaryColor = getAppInformationValue(
+      "secondaryColor"
+    );
+    return secondaryColor || "#1E9CD7";
+  }, [getAppInformationValue]);
+  const appAccentColor = useMemo(() => {
+    const accentColor = getAppInformationValue("accentColor");
+    return accentColor || "#FF6501";
+  }, [getAppInformationValue]);
+  const icon = useMemo(() => {
+    const icon2 = getAppInformationValue("icon");
+    return fileUrl(icon2) || "";
+  }, [getAppInformationValue, fileUrl]);
+  const logo = useMemo(() => {
+    const logo2 = getAppInformationValue("logo");
+    return fileUrl(logo2) || "";
+  }, [getAppInformationValue, fileUrl]);
+  return {
+    logo,
+    icon,
+    page,
+    pageData,
+    newsArticle,
+    newsCategory,
+    newsTag,
+    contentModelItem,
+    getProps,
+    getMenu,
+    getMenuByLocation,
+    getMenuItems,
+    getMenuItemById,
+    getMenuItemsByLocation,
+    getMenuGroups,
+    getMenuItemsByGroup,
+    getMenuGroupedItems,
+    getMenuUngroupedItems,
+    getSectionData,
+    getSectionSettings,
+    getSectionSettingsGroup,
+    getSectionSetting,
+    getAnySectionData,
+    getSectionsInOrder,
+    getFinalPageSections,
+    getSectionRootData,
+    getComponents,
+    getContentModel,
+    getContentModelItems,
+    getPaginatedContentModelItems,
+    getAppInformationValue,
+    appAccentColor,
+    appPrimaryColor,
+    appSecondaryColor
+  };
+};
+const useNewsletter = () => {
+  const { request } = useApi();
+  const [isLoading, setIsLoading] = useState(false);
+  const subscribe = useCallback(
+    async (type, contact, successCallback, errorCallback) => {
+      setIsLoading(true);
+      const task = await request({
+        url: `newsletter/${type}s`,
+        method: "post",
+        data: type === "email" ? { email: contact } : { phone: contact }
+      });
+      if (task.failure && task.error) {
+        if (errorCallback) errorCallback(task.error?.response?.data);
+      } else {
+        if (successCallback) successCallback();
+      }
+      setIsLoading(false);
+    },
+    [request]
+  );
+  const subscribeEmail = useCallback(
+    async (email, successCallback, errorCallback) => {
+      await subscribe("email", email, successCallback, errorCallback);
+    },
+    [subscribe]
+  );
+  const subscribePhone = useCallback(
+    async (phone, successCallback, errorCallback) => {
+      await subscribe(
+        "phone",
+        phone.replace(/\s+/g, ""),
+        successCallback,
+        errorCallback
+      );
+    },
+    [subscribe]
+  );
+  return {
+    subscribePhone,
+    subscribeEmail,
+    isLoading
+  };
+};
+export {
+  useApi,
+  d as useConfig,
+  useContent,
+  useHelper,
+  useNewsletter,
+  useProps
+};