@m4l/core 0.0.26 → 0.0.29

package/dist/external/side-channel.js

@@ -0,0 +1,105 @@
+import { g as getIntrinsic, c as callBound$1, o as objectInspect } from "../node_modules.js";
+var GetIntrinsic = getIntrinsic;
+var callBound = callBound$1;
+var inspect = objectInspect;
+var $TypeError = GetIntrinsic("%TypeError%");
+var $WeakMap = GetIntrinsic("%WeakMap%", true);
+var $Map = GetIntrinsic("%Map%", true);
+var $weakMapGet = callBound("WeakMap.prototype.get", true);
+var $weakMapSet = callBound("WeakMap.prototype.set", true);
+var $weakMapHas = callBound("WeakMap.prototype.has", true);
+var $mapGet = callBound("Map.prototype.get", true);
+var $mapSet = callBound("Map.prototype.set", true);
+var $mapHas = callBound("Map.prototype.has", true);
+var listGetNode = function(list, key) {
+  for (var prev = list, curr; (curr = prev.next) !== null; prev = curr) {
+    if (curr.key === key) {
+      prev.next = curr.next;
+      curr.next = list.next;
+      list.next = curr;
+      return curr;
+    }
+  }
+};
+var listGet = function(objects, key) {
+  var node = listGetNode(objects, key);
+  return node && node.value;
+};
+var listSet = function(objects, key, value) {
+  var node = listGetNode(objects, key);
+  if (node) {
+    node.value = value;
+  } else {
+    objects.next = {
+      key,
+      next: objects.next,
+      value
+    };
+  }
+};
+var listHas = function(objects, key) {
+  return !!listGetNode(objects, key);
+};
+var sideChannel = function getSideChannel() {
+  var $wm;
+  var $m;
+  var $o;
+  var channel = {
+    assert: function(key) {
+      if (!channel.has(key)) {
+        throw new $TypeError("Side channel does not contain " + inspect(key));
+      }
+    },
+    get: function(key) {
+      if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
+        if ($wm) {
+          return $weakMapGet($wm, key);
+        }
+      } else if ($Map) {
+        if ($m) {
+          return $mapGet($m, key);
+        }
+      } else {
+        if ($o) {
+          return listGet($o, key);
+        }
+      }
+    },
+    has: function(key) {
+      if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
+        if ($wm) {
+          return $weakMapHas($wm, key);
+        }
+      } else if ($Map) {
+        if ($m) {
+          return $mapHas($m, key);
+        }
+      } else {
+        if ($o) {
+          return listHas($o, key);
+        }
+      }
+      return false;
+    },
+    set: function(key, value) {
+      if ($WeakMap && key && (typeof key === "object" || typeof key === "function")) {
+        if (!$wm) {
+          $wm = new $WeakMap();
+        }
+        $weakMapSet($wm, key, value);
+      } else if ($Map) {
+        if (!$m) {
+          $m = new $Map();
+        }
+        $mapSet($m, key, value);
+      } else {
+        if (!$o) {
+          $o = { key: {}, next: null };
+        }
+        listSet($o, key, value);
+      }
+    }
+  };
+  return channel;
+};
+export { sideChannel as s };

package/dist/hooks/index.d.ts

@@ -1,6 +1,9 @@
-export { useLocalStorage } from './useLocalStorage';
+export { useFlags, useFlagsPresent } from './useFlags';
 export { useHostTools } from './useHostTools';
+export { useLocalStorage } from './useLocalStorage';
+export { useModuleDictionary } from './useModuleDictionary';
 export { useNetwork } from './useNetwork';
 export { useEnvironment } from './useEnvironment';
-export { useFlags, useFlagsPresent } from './useFlags';
-export { useModuleDictionary } from './useModuleDictionary';
+export { usePaginate } from './usePaginate';
+export type { PagerState } from './usePaginate/types';
+export { initialPagerState } from './usePaginate/types';

package/dist/hooks/usePaginate/index.d.ts

@@ -0,0 +1,15 @@
+import type { PagerState } from './types';
+export interface propsUsePaginate {
+    endPoint: string;
+    timeout?: number;
+    fireOnEnter?: boolean;
+    queryParams?: Record<string, unknown>;
+}
+export declare const usePaginate: <TRow>(props: propsUsePaginate) => {
+    onPageChange: (newPage: number) => void;
+    onRowsPerPageChange: (newRowsPerPage: number) => void;
+    pagerState: PagerState;
+    rows: TRow[];
+    clearRows: () => void;
+    Refresh: () => void;
+};

package/dist/hooks/usePaginate/index.js

@@ -0,0 +1,72 @@
+import { useState, useRef, useCallback, useEffect } from "react";
+import { u as useHostTools } from "../useHostTools/index.js";
+import { u as useNetwork } from "../useNetwork/index.js";
+const initialPagerState = {
+  page: 0,
+  rowsPerPage: 25,
+  totalRecords: 0
+};
+const usePaginate = (props) => {
+  const { endPoint, timeout = 5e3, queryParams = {}, fireOnEnter = true } = props;
+  const [refresh, setRefresh] = useState(0);
+  const [rows, setRows] = useState([]);
+  const [pagerState, setPagerState] = useState(initialPagerState);
+  const refPagerState = useRef(initialPagerState);
+  const [fire, setFire] = useState(fireOnEnter);
+  const { startProgress, stopProgress } = useHostTools();
+  const { networkOperation } = useNetwork();
+  const Refresh = useCallback(() => {
+    setRefresh((oldValue) => oldValue + 1);
+  }, []);
+  useEffect(() => {
+    let mounted = true;
+    if (!fire) {
+      setFire(true);
+      return;
+    }
+    startProgress();
+    networkOperation({
+      method: "GET",
+      endPoint,
+      timeout,
+      parms: {
+        ...queryParams,
+        page: refPagerState.current.page,
+        limit: refPagerState.current.rowsPerPage
+      }
+    }).then((response) => {
+      if (mounted) {
+        setRows(response.data);
+        refPagerState.current.page = response.pager.page;
+        setPagerState((oldPagerState) => ({
+          ...oldPagerState,
+          page: response.pager.page,
+          totalRecords: response.pager.total
+        }));
+      }
+    }).finally(() => {
+      if (mounted) {
+        stopProgress();
+      }
+    });
+    return function cleanUp() {
+      stopProgress();
+      mounted = false;
+    };
+  }, [refresh, queryParams]);
+  const onPageChange = (newPage) => {
+    refPagerState.current.page = newPage;
+    setRefresh((oldValue) => oldValue + 1);
+  };
+  const onRowsPerPageChange = (newRowsPerPage) => {
+    refPagerState.current.rowsPerPage = newRowsPerPage;
+    setPagerState((oldPagerState) => ({ ...oldPagerState, rowsPerPage: newRowsPerPage }));
+    setRefresh((oldValue) => oldValue + 1);
+  };
+  const clearRows = () => {
+    setRows([]);
+    setPagerState(initialPagerState);
+  };
+  return { onPageChange, onRowsPerPageChange, pagerState, rows, clearRows, Refresh };
+};
+export { initialPagerState as i, usePaginate as u };

package/dist/hooks/usePaginate/types.d.ts

@@ -0,0 +1,6 @@
+export declare interface PagerState {
+    page: number;
+    rowsPerPage: number;
+    totalRecords: number;
+}
+export declare const initialPagerState: PagerState;

package/dist/index.js

@@ -3,17 +3,19 @@ export { H as HostToolsContext, a as HostToolsProvider } from "./contexts/HostTo
 export { N as NetworkContext, a as NetworkProvider } from "./contexts/NetworkContext/index.js";
 export { F as FlagsContext, a as FlagsProvider } from "./contexts/FlagsContext/index.js";
 export { M as ModuleDictionaryContext, a as ModuleDictionaryProvider } from "./contexts/ModuleDictionaryContext/index.js";
-export { u as useLocalStorage } from "./hooks/useLocalStorage/index.js";
+export { u as useFlags, a as useFlagsPresent } from "./hooks/useFlags/index.js";
 export { u as useHostTools } from "./hooks/useHostTools/index.js";
+export { u as useLocalStorage } from "./hooks/useLocalStorage/index.js";
+export { u as useModuleDictionary } from "./hooks/useModuleDictionary/index.js";
 export { u as useNetwork } from "./hooks/useNetwork/index.js";
 export { u as useEnvironment } from "./hooks/useEnvironment/index.js";
-export { u as useFlags, a as useFlagsPresent } from "./hooks/useFlags/index.js";
-export { u as useModuleDictionary } from "./hooks/useModuleDictionary/index.js";
+export { i as initialPagerState, u as usePaginate } from "./hooks/usePaginate/index.js";
 export { E as EmitEvents } from "./types/index.js";
 export { a as getLocalStorage, g as getPropertyByString, s as setLocalStorage, v as voidFunction } from "./utils/index.js";
 export { a as axiosOperation } from "./external/axios.js";
 import "react";
 import "react/jsx-runtime";
+import "./external/qs.js";
+import "./external/side-channel.js";
 import "./node_modules.js";
 import "./vendor.js";
-import "./external/snakecase-keys.js";