@ebubekirylmaz/link-test 1.0.0

package/src/lib/lib/Icons.js

@@ -0,0 +1,40 @@
+const Icons = [
+  {
+    id: "project_icons",
+    name: "Project Icons",
+    emojis: [
+      "solar/book-2-line-duotone",
+      "solar/chat-square-2-line-duotone",
+      "solar/chat-square-code-line-duotone",
+      "solar/cpu-line-duotone",
+    ].map((icon) => ({
+      id: icon,
+      skins: [
+        {
+          src: `https://api.iconify.design/${icon}.svg?color=%232065d1&width=75&height=75'`,
+        },
+      ],
+    })),
+  },
+  {
+    id: "service_icons",
+    name: "Service Icons",
+    emojis: [
+      "solar/asteroid-line-duotone",
+      "solar/atom-line-duotone",
+      "solar/accessibility-line-duotone",
+      "solar/backpack-line-duotone",
+      "solar/battery-charge-line-duotone",
+      "solar/black-hole-3-line-duotone",
+    ].map((icon) => ({
+      id: icon,
+      skins: [
+        {
+          src: `https://api.iconify.design/${icon}.svg?color=%232065d1&width=75&height=75'`,
+        },
+      ],
+    })),
+  },
+];
+
+export default Icons;

package/src/lib/lib/context.json

@@ -0,0 +1,272 @@
+{
+    "context": {
+        "nucleoid": {
+            "api": [
+                {
+                    "path": "/",
+                    "method": "GET",
+                    "params": [
+                        {
+                            "name": "example",
+                            "in": "query",
+                            "type": "string",
+                            "required": false,
+                            "description": "example"
+                        }
+                    ],
+                    "response": "object",
+                    "x-nuc-action": "function action(req: any): { message: string } {\n        return { message: \"Hello World\" };\n      }"
+                },
+                {
+                    "path": "/items",
+                    "method": "GET",
+                    "params": [
+                        {
+                            "in": "query",
+                            "type": "string",
+                            "required": true,
+                            "name": "name"
+                        }
+                    ],
+                    "response": "Item[]",
+                    "x-nuc-action": "function action(req: { query: { name: string } }): any {\n      const name = req.query.name;\n      return Item.filter(item => item.name === name);\n    }"
+                },
+                {
+                    "path": "/items",
+                    "method": "POST",
+                    "request": {
+                        "type": "object",
+                        "properties": {
+                            "name": {
+                                "type": "string"
+                            },
+                            "barcode": {
+                                "type": "string"
+                            }
+                        }
+                    },
+                    "response": "Item",
+                    "x-nuc-action": "function action(req: { body: { name: string, barcode: string } }): any {\n      const name = req.body.name;\n      const barcode = req.body.barcode;\n      const check = Item.find(i => i.barcode === barcode);\n      if(check) {\n        throw \"DUPLICATE_BARCODE\";\n      }\n      return new Item(name, barcode);\n    }"
+                },
+                {
+                    "path": "/items/{item}",
+                    "method": "GET",
+                    "params": [
+                        {
+                            "name": "item",
+                            "in": "path",
+                            "type": "string",
+                            "required": true,
+                            "description": "item"
+                        }
+                    ],
+                    "response": "Item",
+                    "x-nuc-action": "function action(req: { params: { item: string } }): any {\n      const item = req.params.item;\n      return Item[item];\n    }"
+                },
+                {
+                    "path": "/items/{item}",
+                    "method": "PUT",
+                    "params": [
+                        {
+                            "name": "item",
+                            "in": "path",
+                            "type": "string",
+                            "required": true,
+                            "description": "item"
+                        }
+                    ],
+                    "request": {
+                        "type": "object",
+                        "properties": {
+                            "name": {
+                                "type": "string"
+                            },
+                            "barcode": {
+                                "type": "string"
+                            }
+                        }
+                    },
+                    "response": "Item",
+                    "x-nuc-action": "function action(req: { params: { item: string }, body: { name: string, barcode: string } }): any {\n      const item = Item[req.params.item];\n      const name = req.body.name;\n      const barcode = req.body.barcode;\n      if (!item) {\n        return;\n      }\n      const check = Item.find(\n        i => i.barcode === barcode && i.barcode !== item.barcode\n      );\n      if (check) {\n        throw \"DUPLICATE_BARCODE\";\n      }\n      item.name = name;\n      item.barcode = barcode;\n      return item;\n    }"
+                },
+                {
+                    "path": "/items/{item}",
+                    "method": "DEL",
+                    "params": [
+                        {
+                            "name": "item",
+                            "in": "path",
+                            "type": "string",
+                            "required": true,
+                            "description": "item"
+                        }
+                    ],
+                    "response": "object",
+                    "x-nuc-action": "function action(req: { params: { item: string } }): void {\n      const item = req.params.item;\n      delete Item[item];\n    }"
+                },
+                {
+                    "path": "/orders",
+                    "method": "GET",
+                    "params": [],
+                    "response": "Order[]",
+                    "x-nuc-action": "function action(req: any): any {\n      return Order;\n    }"
+                },
+                {
+                    "path": "/orders",
+                    "method": "POST",
+                    "request": {
+                        "type": "object",
+                        "properties": {
+                            "item": {
+                                "type": "string"
+                            },
+                            "qty": {
+                                "type": "integer"
+                            }
+                        }
+                    },
+                    "response": "Order",
+                    "x-nuc-action": "function action(req: { body: { item: string, qty: number } }): any {\n      const item = Item[req.body.item];\n      const qty = req.body.qty;\n      if (!item) {\n        throw \"INVALID_ITEM\";\n      }\n      return new Order(item, qty);\n    }"
+                },
+                {
+                    "path": "/orders/{order}",
+                    "method": "GET",
+                    "params": [
+                        {
+                            "name": "order",
+                            "in": "path",
+                            "type": "string",
+                            "required": true,
+                            "description": "order"
+                        }
+                    ],
+                    "response": "Order",
+                    "x-nuc-action": "function action(req: { params: { order: string } }): any {\n      const order = req.params.order;\n      return Order[order];\n    }"
+                },
+                {
+                    "path": "/orders/{order}",
+                    "method": "PUT",
+                    "params": [
+                        {
+                            "name": "order",
+                            "in": "path",
+                            "type": "string",
+                            "required": true,
+                            "description": "Order id"
+                        }
+                    ],
+                    "request": {
+                        "type": "object",
+                        "properties": {
+                            "item": {
+                                "type": "string"
+                            },
+                            "qty": {
+                                "type": "integer"
+                            }
+                        }
+                    },
+                    "response": "Order",
+                    "x-nuc-action": "function action(req: { params: { order: string }, body: { item: string, qty: number } }): any {\n      const order = Order[req.params.order];\n      const item = Item[req.body.item];\n      const qty = req.body.qty;\n      if (!order) {\n        return;\n      }\n      if (!item) {\n        throw \"INVALID_ITEM\";\n      }\n      order.item = item;\n      order.qty = qty;\n      return order;\n    }"
+                },
+                {
+                    "path": "/orders/{order}",
+                    "method": "DEL",
+                    "params": [
+                        {
+                            "name": "order",
+                            "in": "path",
+                            "type": "string",
+                            "required": true,
+                            "description": "Order id"
+                        }
+                    ],
+                    "response": "object",
+                    "x-nuc-action": "function action(req: { params: { order: string } }): void {\n      const order = req.params.order;\n      delete Order[order];\n    }"
+                }
+            ],
+            "types": [
+                {
+                    "path": "/Order",
+                    "params": [],
+                    "type": "CLASS",
+                    "definition": "class Order1 {\n  item: string;\n  qty: number;\n  date: number;\n  constructor(item: string, qty: number) {\n    this.item = item;\n    this.qty = qty;\n    this.date = Date.now();\n  }\n}"
+                },
+                {
+                    "path": "/Item",
+                    "params": [],
+                    "type": "CLASS",
+                    "definition": "class Item1 {\n  name: string;\n  barcode: string;\n  constructor(name: string, barcode: string) {\n    this.name = name;\n    this.barcode = barcode;\n  }\n}"
+                },
+                {
+                    "path": "/event",
+                    "params": [],
+                    "type": "FUNCTION",
+                    "builtin": true,
+                    "definition": "function event(name: string, data: any): void {}"
+                },
+                {
+                    "path": "/uuid",
+                    "params": [],
+                    "type": "FUNCTION",
+                    "builtin": true,
+                    "definition": "function uuid(): void {}"
+                },
+                {
+                    "path": "/random",
+                    "params": [],
+                    "type": "FUNCTION",
+                    "builtin": true,
+                    "definition": "function random(length: number): void {}"
+                }
+            ],
+            "functions": [
+                {
+                    "path": "/Order",
+                    "params": [],
+                    "type": "CLASS",
+                    "ext": "js",
+                    "definition": "class Order {\n  constructor(item, qty) {\n    this.item = item;\n    this.qty = qty;\n    this.date = Date.now();\n  }\n}\n"
+                },
+                {
+                    "path": "/Item",
+                    "params": [],
+                    "type": "CLASS",
+                    "ext": "js",
+                    "definition": "class Item {\n  constructor(name, barcode) {\n    this.name = name;\n    this barcode = barcode;\n  }\n}\n"
+                }
+            ]
+        },
+        "pages": {
+            "started": false,
+            "opened": false,
+            "api": {
+                "dialog": {
+                    "view": "BODY",
+                    "type": "",
+                    "action": ""
+                },
+                "resourceMenu": {
+                    "open": false,
+                    "anchor": {}
+                },
+                "selected": {
+                    "path": "/",
+                    "method": "get"
+                }
+            },
+            "functions": {
+                "dialog": {
+                    "open": false
+                },
+                "selected": "/Order"
+            },
+            "query": {
+                "results": "",
+                "text": "Item.filter((item) => item.name === \"item-1\");",
+                "outputRatio": 0.5
+            },
+            "branches": {}
+        }
+    }
+}

package/src/lib/useChart/useChart.js

@@ -0,0 +1,179 @@
+import merge from "lodash/merge";
+import { useResponsive } from "../../hooks/use-responsive";
+
+import { alpha, useTheme } from "@mui/material/styles";
+
+export default function useChart(options) {
+  const theme = useTheme();
+
+  const smUp = useResponsive("up", "sm");
+
+  const LABEL_TOTAL = {
+    show: true,
+    label: "Total",
+    color: theme.palette.text.secondary,
+    fontSize: theme.typography.subtitle2.fontSize,
+    fontWeight: theme.typography.subtitle2.fontWeight,
+    lineHeight: theme.typography.subtitle2.lineHeight,
+  };
+
+  const LABEL_VALUE = {
+    offsetY: 8,
+    color: theme.palette.text.primary,
+    fontSize: theme.typography.h3.fontSize,
+    fontWeight: theme.typography.h3.fontWeight,
+    lineHeight: theme.typography.h3.lineHeight,
+  };
+
+  const baseOptions = {
+    colors: [
+      theme.palette.primary.main,
+      theme.palette.warning.main,
+      theme.palette.info.main,
+      theme.palette.error.main,
+      theme.palette.success.main,
+      theme.palette.warning.dark,
+      theme.palette.success.darker,
+      theme.palette.info.dark,
+      theme.palette.info.darker,
+    ],
+
+    chart: {
+      toolbar: { show: false },
+      zoom: { enabled: false },
+      foreColor: theme.palette.text.disabled,
+      fontFamily: theme.typography.fontFamily,
+    },
+
+    states: {
+      hover: {
+        filter: {
+          type: "lighten",
+          value: 0.04,
+        },
+      },
+      active: {
+        filter: {
+          type: "darken",
+          value: 0.88,
+        },
+      },
+    },
+    fill: {
+      opacity: 1,
+      gradient: {
+        type: "vertical",
+        shadeIntensity: 0,
+        opacityFrom: 0.4,
+        opacityTo: 0,
+        stops: [0, 100],
+      },
+    },
+    dataLabels: {
+      enabled: false,
+    },
+    stroke: {
+      width: 3,
+      curve: "smooth",
+      lineCap: "round",
+    },
+    grid: {
+      strokeDashArray: 3,
+      borderColor: theme.palette.divider,
+      xaxis: {
+        lines: {
+          show: false,
+        },
+      },
+    },
+    xaxis: {
+      axisBorder: { show: false },
+      axisTicks: { show: false },
+    },
+    markers: {
+      size: 0,
+      strokeColors: theme.palette.background.paper,
+    },
+    tooltip: {
+      theme: false,
+      x: {
+        show: true,
+      },
+    },
+    legend: {
+      show: true,
+      fontSize: 13,
+      position: "top",
+      horizontalAlign: "right",
+      markers: {
+        radius: 12,
+      },
+      fontWeight: 500,
+      itemMargin: {
+        horizontal: 8,
+      },
+      labels: {
+        colors: theme.palette.text.primary,
+      },
+    },
+    plotOptions: {
+      bar: {
+        borderRadius: smUp ? 3 : 1,
+        columnWidth: "28%",
+        borderRadiusApplication: "end",
+        borderRadiusWhenStacked: "last",
+      },
+      pie: {
+        donut: {
+          labels: {
+            show: true,
+            value: LABEL_VALUE,
+            total: LABEL_TOTAL,
+          },
+        },
+      },
+
+      radialBar: {
+        track: {
+          strokeWidth: "100%",
+          background: alpha(theme.palette.grey[500], 0.16),
+        },
+        dataLabels: {
+          value: LABEL_VALUE,
+          total: LABEL_TOTAL,
+        },
+      },
+      radar: {
+        polygons: {
+          fill: { colors: ["transparent"] },
+          strokeColors: theme.palette.divider,
+          connectorColors: theme.palette.divider,
+        },
+      },
+      polarArea: {
+        rings: {
+          strokeColor: theme.palette.divider,
+        },
+        spokes: {
+          connectorColors: theme.palette.divider,
+        },
+      },
+    },
+    responsive: [
+      {
+        breakpoint: theme.breakpoints.values.sm,
+        options: {
+          plotOptions: { bar: { columnWidth: "40%" } },
+        },
+      },
+      {
+        breakpoint: theme.breakpoints.values.md,
+        options: {
+          plotOptions: { bar: { columnWidth: "32%" } },
+        },
+      },
+    ],
+  };
+
+  return merge(baseOptions, options);
+}

package/src/lib/useTable/useTable.js

@@ -0,0 +1,121 @@
+import { useCallback, useState } from "react";
+
+export default function useTable(props) {
+  const [dense, setDense] = useState(!!props?.defaultDense);
+
+  const [page, setPage] = useState(props?.defaultCurrentPage || 0);
+
+  const [orderBy, setOrderBy] = useState(props?.defaultOrderBy || "name");
+
+  const [rowsPerPage, setRowsPerPage] = useState(
+    props?.defaultRowsPerPage || 5
+  );
+
+  const [order, setOrder] = useState(props?.defaultOrder || "asc");
+
+  const [selected, setSelected] = useState(props?.defaultSelected || []);
+
+  const onSort = useCallback(
+    (id) => {
+      const isAsc = orderBy === id && order === "asc";
+      if (id !== "") {
+        setOrder(isAsc ? "desc" : "asc");
+        setOrderBy(id);
+      }
+    },
+    [order, orderBy]
+  );
+
+  const onSelectRow = useCallback(
+    (inputValue) => {
+      const newSelected = selected.includes(inputValue)
+        ? selected.filter((value) => value !== inputValue)
+        : [...selected, inputValue];
+
+      setSelected(newSelected);
+    },
+    [selected]
+  );
+
+  const onChangeRowsPerPage = useCallback((event) => {
+    setPage(0);
+    setRowsPerPage(parseInt(event.target.value, 10));
+  }, []);
+
+  const onChangeDense = useCallback((event) => {
+    setDense(event.target.checked);
+  }, []);
+
+  const onSelectAllRows = useCallback((checked, inputValue) => {
+    if (checked) {
+      setSelected(inputValue);
+      return;
+    }
+    setSelected([]);
+  }, []);
+
+  const onChangePage = useCallback((event, newPage) => {
+    setPage(newPage);
+  }, []);
+
+  const onResetPage = useCallback(() => {
+    setPage(0);
+  }, []);
+
+  const onUpdatePageDeleteRow = useCallback(
+    (totalRowsInPage) => {
+      setSelected([]);
+      if (page) {
+        if (totalRowsInPage < 2) {
+          setPage(page - 1);
+        }
+      }
+    },
+    [page]
+  );
+
+  const onUpdatePageDeleteRows = useCallback(
+    ({ totalRows, totalRowsInPage, totalRowsFiltered }) => {
+      const totalSelected = selected.length;
+
+      setSelected([]);
+
+      if (page) {
+        if (totalSelected === totalRowsInPage) {
+          setPage(page - 1);
+        } else if (totalSelected === totalRowsFiltered) {
+          setPage(0);
+        } else if (totalSelected > totalRowsInPage) {
+          const newPage =
+            Math.ceil((totalRows - totalSelected) / rowsPerPage) - 1;
+          setPage(newPage);
+        }
+      }
+    },
+    [page, rowsPerPage, selected.length]
+  );
+
+  return {
+    dense,
+    order,
+    page,
+    orderBy,
+    rowsPerPage,
+    selected,
+    onSelectRow,
+    onSelectAllRows,
+    onSort,
+    onChangePage,
+    onChangeDense,
+    onResetPage,
+    onChangeRowsPerPage,
+    onUpdatePageDeleteRow,
+    onUpdatePageDeleteRows,
+    setPage,
+    setDense,
+    setOrder,
+    setOrderBy,
+    setSelected,
+    setRowsPerPage,
+  };
+}

package/src/pages/404.jsx

@@ -0,0 +1,17 @@
+import { Helmet } from "react-helmet-async";
+import { NotFoundView } from "../widgets/error";
+import React from "react";
+
+// ----------------------------------------------------------------------
+
+export default function NotFoundPage() {
+  return (
+    <>
+      <Helmet>
+        <title> 404 Page Not Found!</title>
+      </Helmet>
+
+      <NotFoundView />
+    </>
+  );
+}