@ebubekirylmaz/link-test 1.0.0

package/src/config/schemas.js

@@ -0,0 +1,148 @@
+import Joi from "joi";
+
+export const ConfigSchema = Joi.object({
+  appId: Joi.string().uuid().required(),
+  name: Joi.string().required(),
+  beta: Joi.boolean().optional(),
+  base: Joi.string().required(),
+  api: Joi.string().uri().required(),
+  socket: Joi.object({
+    host: Joi.string().uri().required(),
+    path: Joi.string().required(),
+  }).optional(),
+  credentials: Joi.object({
+    provider: Joi.string().valid("DEMO", "COGNITO").required(),
+    region: Joi.string().required(),
+    userPoolId: Joi.string().required(),
+    clientId: Joi.string().required(),
+  }).optional(),
+  project: Joi.object({
+    nucleoid: Joi.object().optional(),
+    github: Joi.object({
+      authUrl: Joi.string().uri().required(),
+      clientId: Joi.string().required(),
+      redirectUri: Joi.string().uri().required(),
+      scope: Joi.string().required(),
+      response_type: Joi.string().required(),
+      userUrl: Joi.string().uri().required(),
+    }).optional(),
+    google: Joi.object({
+      authUrl: Joi.string().uri().required(),
+      clientId: Joi.string().required(),
+      redirectUri: Joi.string().uri().required(),
+      scope: Joi.string().required(),
+      response_type: Joi.string().required(),
+      userUrl: Joi.string().uri().required(),
+    }).optional(),
+    linkedin: Joi.object({
+      authUrl: Joi.string().uri().required(),
+      clientId: Joi.string().required(),
+      redirectUri: Joi.string().uri().required(),
+      scope: Joi.string().required(),
+      response_type: Joi.string().required(),
+      userUrl: Joi.string().uri().required(),
+    }).optional(),
+  }).optional(),
+}).required();
+
+export const MenuConfigSchema = Joi.object({
+  sideMenu: Joi.array()
+    .items(
+      Joi.object({
+        subheader: Joi.string().required(),
+        items: Joi.array()
+          .items(
+            Joi.object({
+              title: Joi.string().required(),
+              icon: Joi.string().required(),
+              path: Joi.string().required(),
+              external: Joi.boolean().optional().default(false),
+              children: Joi.array()
+                .items(
+                  Joi.object({
+                    title: Joi.string().required(),
+                    path: Joi.string().required(),
+                    icon: Joi.string().required(),
+                    external: Joi.boolean().optional().default(false),
+                  })
+                )
+                .optional(),
+            })
+          )
+          .required(),
+      })
+    )
+    .optional()
+    .default([]),
+  topMenu: Joi.array()
+    .items(
+      Joi.object({
+        title: Joi.string().required(),
+        icon: Joi.string().required(),
+        path: Joi.string().required(),
+      })
+    )
+    .optional()
+    .default([]),
+  options: Joi.array()
+    .items(
+      Joi.object({
+        label: Joi.string().required(),
+        linkTo: Joi.string().required(),
+      })
+    )
+    .optional()
+    .default([]),
+  actionButtons: Joi.array().items(Joi.any()).optional().default([]),
+  fullScreenLayout: Joi.string()
+    .valid("left", "right")
+    .optional()
+    .default("left"),
+}).required();
+
+export const TemplateConfigSchema = Joi.object({
+  login: Joi.object({
+    variant: Joi.string()
+      .valid("classic", "modern")
+      .optional()
+      .default("classic"),
+    image: Joi.string()
+      .optional()
+      .default("https://minimals.cc/assets/background/overlay_3.jpg"),
+    largeIcon: Joi.string()
+      .optional()
+      .default("https://cdn.nucleoid.com/media/icon.png"),
+    icon: Joi.string()
+      .optional()
+      .default("https://cdn.nucleoid.com/media/icon.png"),
+  }).optional(),
+  theme: Joi.object({
+    variants: Joi.function().optional(),
+    mode: Joi.string().valid("light", "dark").optional().default("dark"),
+    colorPresets: Joi.string()
+      .valid("default", "cyan", "purple", "blue", "orange", "red")
+      .optional()
+      .default("default"),
+  })
+    .optional()
+    .default({ mode: "dark", colorPresets: "cyan" }),
+  projectBar: Joi.object({
+    label: Joi.string().optional().default("Project"),
+  }).optional(),
+  icon: Joi.string()
+    .optional()
+    .default("https://cdn.nucleoid.com/media/icon.png"),
+  settings: Joi.object({
+    tabs: Joi.array()
+      .items(
+        Joi.object({
+          label: Joi.string().required(),
+          panel: Joi.any().required(),
+        })
+      )
+      .optional()
+      .default([]),
+  })
+    .optional()
+    .default({ tabs: [] }),
+});

package/src/context/reducer.js

@@ -0,0 +1,52 @@
+import { jwtDecode } from "jwt-decode";
+import { storage } from "@nucleoidjs/webstorage";
+
+let login = true;
+const itemId = storage.get("itemId");
+try {
+  const token = storage.get("link", "accessToken");
+  const decodedToken = jwtDecode(token);
+
+  if (decodedToken.exp * 1000 < Date.now()) {
+    login = false;
+  }
+} catch (err) {
+  login = false;
+}
+
+export const initialState = {
+  login,
+  itemId,
+};
+
+export const reducer = (state, action) => {
+  state = { ...state };
+
+  switch (action.type) {
+    case "LOGIN": {
+      state.login = true;
+      break;
+    }
+    case "LOGOUT": {
+      storage.clear();
+      state.login = false;
+      break;
+    }
+
+    case "ITEM_SELECT": {
+      state.itemId = action.payload;
+      storage.set("itemId", state.itemId);
+      break;
+    }
+
+    case "ITEM_DELETE": {
+      storage.remove("itemId");
+      state.itemId = null;
+      break;
+    }
+
+    default:
+  }
+
+  return state;
+};

package/src/global.css

@@ -0,0 +1,2 @@
+/* scrollbar */
+@import 'simplebar-react/dist/simplebar.min.css';

package/src/hooks/index.js

@@ -0,0 +1,2 @@
+import useApi from "./useApi";
+export { useApi };

package/src/hooks/use-boolean.js

@@ -0,0 +1,27 @@
+import { useCallback, useState } from "react";
+
+// ----------------------------------------------------------------------
+
+export function useBoolean(defaultValue) {
+  const [value, setValue] = useState(!!defaultValue);
+
+  const onTrue = useCallback(() => {
+    setValue(true);
+  }, []);
+
+  const onFalse = useCallback(() => {
+    setValue(false);
+  }, []);
+
+  const onToggle = useCallback(() => {
+    setValue((prev) => !prev);
+  }, []);
+
+  return {
+    value,
+    onTrue,
+    onFalse,
+    onToggle,
+    setValue,
+  };
+}

package/src/hooks/use-event-listener.js

@@ -0,0 +1,34 @@
+import { useEffect, useLayoutEffect, useRef } from "react";
+
+// ----------------------------------------------------------------------
+
+const useIsomorphicLayoutEffect =
+  typeof window !== "undefined" ? useLayoutEffect : useEffect;
+
+export function useEventListener(eventName, handler, element, options) {
+  // Create a ref that stores handler
+  const savedHandler = useRef(handler);
+
+  useIsomorphicLayoutEffect(() => {
+    savedHandler.current = handler;
+  }, [handler]);
+
+  useEffect(() => {
+    // Define the listening target
+    const targetElement = element?.current || window;
+    if (!(targetElement && targetElement.addEventListener)) {
+      return;
+    }
+
+    // Create event listener that calls handler function stored in ref
+    const eventListener = (event) => savedHandler.current(event);
+
+    targetElement.addEventListener(eventName, eventListener, options);
+
+    // Remove event listener on cleanup
+    // eslint-disable-next-line consistent-return
+    return () => {
+      targetElement.removeEventListener(eventName, eventListener);
+    };
+  }, [eventName, element, options]);
+}

package/src/hooks/use-local-storage.js

@@ -0,0 +1,89 @@
+import { useCallback, useEffect, useState } from "react";
+
+// ----------------------------------------------------------------------
+
+export function useLocalStorage(key, initialState) {
+  const [state, setState] = useState(initialState);
+
+  useEffect(() => {
+    const restored = getStorage(key);
+
+    if (restored) {
+      setState((prevValue) => ({
+        ...prevValue,
+        ...restored,
+      }));
+    }
+  }, [key]);
+
+  const updateState = useCallback(
+    (updateValue) => {
+      setState((prevValue) => {
+        setStorage(key, {
+          ...prevValue,
+          ...updateValue,
+        });
+
+        return {
+          ...prevValue,
+          ...updateValue,
+        };
+      });
+    },
+    [key]
+  );
+
+  const update = useCallback(
+    (name, updateValue) => {
+      updateState({
+        [name]: updateValue,
+      });
+    },
+    [updateState]
+  );
+
+  const reset = useCallback(() => {
+    removeStorage(key);
+    setState(initialState);
+  }, [initialState, key]);
+
+  return {
+    state,
+    update,
+    reset,
+  };
+}
+
+// ----------------------------------------------------------------------
+
+export const getStorage = (key) => {
+  let value = null;
+
+  try {
+    const result = window.localStorage.getItem(key);
+
+    if (result) {
+      value = JSON.parse(result);
+    }
+  } catch (error) {
+    console.error(error);
+  }
+
+  return value;
+};
+
+export const setStorage = (key, value) => {
+  try {
+    window.localStorage.setItem(key, JSON.stringify(value));
+  } catch (error) {
+    console.error(error);
+  }
+};
+
+export const removeStorage = (key) => {
+  try {
+    window.localStorage.removeItem(key);
+  } catch (error) {
+    console.error(error);
+  }
+};

package/src/hooks/use-off-set-top.js

@@ -0,0 +1,37 @@
+import { useScroll } from "framer-motion";
+
+import { useCallback, useEffect, useMemo, useState } from "react";
+
+// ----------------------------------------------------------------------
+
+export function useOffSetTop(top = 0, options) {
+  const { scrollY } = useScroll(options);
+
+  const [value, setValue] = useState(false);
+
+  const onOffSetTop = useCallback(() => {
+    scrollY.on("change", (scrollHeight) => {
+      if (scrollHeight > top) {
+        setValue(true);
+      } else {
+        setValue(false);
+      }
+    });
+  }, [scrollY, top]);
+
+  useEffect(() => {
+    onOffSetTop();
+  }, [onOffSetTop]);
+
+  const memoizedValue = useMemo(() => value, [value]);
+
+  return memoizedValue;
+}
+
+// Usage
+// const offset = useOffSetTop(100);
+
+// Or
+// const offset = useOffSetTop(100, {
+//   container: ref,
+// });

package/src/hooks/use-responsive.js

@@ -0,0 +1,47 @@
+import useMediaQuery from "@mui/material/useMediaQuery";
+import { useTheme } from "@mui/material/styles";
+
+// ----------------------------------------------------------------------
+
+export function useResponsive(query, start, end) {
+  const theme = useTheme();
+
+  const mediaUp = useMediaQuery(theme.breakpoints.up(start));
+
+  const mediaDown = useMediaQuery(theme.breakpoints.down(start));
+
+  const mediaBetween = useMediaQuery(theme.breakpoints.between(start, end));
+
+  const mediaOnly = useMediaQuery(theme.breakpoints.only(start));
+
+  if (query === "up") {
+    return mediaUp;
+  }
+
+  if (query === "down") {
+    return mediaDown;
+  }
+
+  if (query === "between") {
+    return mediaBetween;
+  }
+
+  return mediaOnly;
+}
+
+// ----------------------------------------------------------------------
+
+export function useWidth() {
+  const theme = useTheme();
+
+  const keys = [...theme.breakpoints.keys].reverse();
+
+  return (
+    keys.reduce((output, key) => {
+      // eslint-disable-next-line react-hooks/rules-of-hooks
+      const matches = useMediaQuery(theme.breakpoints.up(key));
+
+      return !output && matches ? key : output;
+    }, null) || "xs"
+  );
+}

package/src/hooks/use-scroll-to-top.js

@@ -0,0 +1,14 @@
+import { useEffect } from "react";
+import { useLocation } from "react-router-dom";
+
+// ----------------------------------------------------------------------
+
+export function useScrollToTop() {
+  const { pathname } = useLocation();
+
+  useEffect(() => {
+    window.scrollTo(0, 0);
+  }, [pathname]);
+
+  return null;
+}

package/src/hooks/use-user.js

@@ -0,0 +1,58 @@
+import http from "../http";
+import { publish } from "@nucleoidai/react-event";
+import useApi from "./useApi";
+import userInstance from "../http/user";
+
+import { useCallback, useEffect, useState } from "react";
+
+export function useUser() {
+  const [user, setUser] = useState({ name: "", avatarUrl: "" });
+  const [users, setUsers] = useState([]);
+  const { loading, error, handleResponse } = useApi();
+
+  useEffect(() => {
+    getUser();
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  const getUser = useCallback(() => {
+    handleResponse(userInstance.getUserDetails(), (response) =>
+      setUser(response)
+    );
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  const getPermittedUsers = useCallback(() => {
+    handleResponse(userInstance.getPermittedUsers(), (response) =>
+      setUsers(response)
+    );
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+
+  const createPermission = useCallback((userId) => {
+    handleResponse(
+      http.post("/permissions", {
+        userId,
+      }),
+      (response) => {
+        publish("PERMISSION_CREATED", { userId: response.data.id });
+      }
+    );
+  }, []);
+
+  const deletePermission = useCallback((userId) => {
+    handleResponse(http.delete(`/permissions/${userId}`), (response) => {
+      publish("PERMISSION_DELETED", { userId: response.data.id });
+    });
+  }, []);
+
+  return {
+    user,
+    users,
+    loading,
+    error,
+    getPermittedUsers,
+    createPermission,
+    deletePermission,
+  };
+}

package/src/hooks/useApi.js

@@ -0,0 +1,25 @@
+import { useState } from "react";
+
+function useApi() {
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+
+  const handleResponse = async (promise, callback, successCallback) => {
+    setLoading(true);
+    setError(null);
+    try {
+      const response = await promise;
+      callback(response);
+      if (successCallback) {
+        successCallback();
+      }
+    } catch (err) {
+      setError(err.message);
+    } finally {
+      setLoading(false);
+    }
+  };
+  return { loading, error, handleResponse };
+}
+
+export default useApi;

package/src/hooks/useItemsState.js

@@ -0,0 +1,23 @@
+import axios from "axios";
+import config from "../../../../config";
+import templateConfig from "../../../../config.template";
+import useSWR from "swr";
+
+const instance = axios.create({
+  baseURL: config.api,
+});
+
+const fetcher = (url) => instance.get(url).then((res) => res.data);
+
+export const useProject = () => {
+  const GetItems = () => {
+    const path = templateConfig.projectBar.path;
+    const { data, error } = useSWR(path, fetcher);
+
+    return { items: data || [], loading: !error && !data };
+  };
+
+  return {
+    GetItems,
+  };
+};

package/src/hooks/useProjects.js

@@ -0,0 +1,24 @@
+import http from "../http";
+import useApi from "./useApi";
+
+import { useCallback, useState } from "react";
+
+function useProjects() {
+  const [projects, setProjects] = useState([]);
+  const { loading, error, handleResponse } = useApi();
+
+  const getProjects = useCallback(() => {
+    handleResponse(http.get("/projects"), (response) => {
+      setProjects(response.data);
+    });
+  }, []);
+
+  return {
+    projects,
+    loading,
+    error,
+    getProjects,
+  };
+}
+
+export default useProjects;

package/src/hooks/useSettings.jsx

@@ -0,0 +1,51 @@
+import http from "../http";
+import useApi from "./useApi";
+
+import { publish, useEvent } from "@nucleoidai/react-event";
+import { useCallback, useEffect, useState } from "react";
+
+function useSettings(id) {
+  const [settings, setSettings] = useState({
+    timeZone: "",
+  });
+  const { loading, error, handleResponse } = useApi();
+  const [settingUpdated] = useEvent("SETTING_UPDATED", null);
+
+  useEffect(() => {
+    if (id) {
+      getSettings(id);
+    }
+  }, [settingUpdated]);
+
+  const getSettings = useCallback(
+    (id) => {
+      handleResponse(http.get(`/projects/${id}/settings`), (response) => {
+        setSettings(response.data);
+      });
+    },
+    [handleResponse]
+  );
+
+  const updateSettings = useCallback(
+    (id, newTimeZone) => {
+      handleResponse(
+        http.patch(`/projects/${id}/settings`, {
+          timeZone: newTimeZone,
+        }),
+        () => {
+          publish("SETTING_UPDATED", { id });
+        }
+      );
+    },
+    [handleResponse, getSettings]
+  );
+
+  return {
+    settings,
+    loading,
+    error,
+    updateSettings,
+  };
+}
+
+export default useSettings;