@peerme/core-ts/dist/hooks.mjs

Core ts library

import {
  PermissionConfig,
  TicketConfig
} from "./chunk-SNYKEVN4.mjs";

// src/hooks/useDebounce.ts
import { useEffect, useState } from "react";
var useDebounce = (value, delay) => {
  const [debouncedValue, setDebouncedValue] = useState(value);
  useEffect(() => {
    const handler = setTimeout(() => setDebouncedValue(value), delay);
    return () => clearTimeout(handler);
  }, [value, delay]);
  return debouncedValue;
};

// src/hooks/useDidMountEffect.ts
import { useEffect as useEffect2, useRef } from "react";
var useDidMountEffect = (effect, deps) => {
  const didMount = useRef(false);
  useEffect2(() => {
    if (didMount.current) effect();
    else didMount.current = true;
  }, deps);
};

// src/hooks/usePermission.ts
var UnrestrictedPermissionName = "*";
var usePermission = (userPermissions) => {
  const isUnrestricted = () => userPermissions.some((p) => p.name === UnrestrictedPermissionName);
  const canAddProposalPayment = () => {
    const canSendEgld = userPermissions.some((p) => !!p.value && BigInt(p.value) > 0);
    const canSendTokens = userPermissions.some((p) => p.payments.length > 0);
    return canSendEgld || canSendTokens || isUnrestricted();
  };
  const canCallContract = () => isUnrestricted() || userPermissions.some((p) => p.endpoint);
  const canManageUsers = () => isUnrestricted() || userPermissions.some((p) => Object.values(PermissionConfig.ContractFunctions).includes(p.endpoint));
  const canCreateTicket = () => isUnrestricted() || userPermissions.some((p) => p.endpoint === TicketConfig.ExecutionScEndpoint);
  const canCreateRoles = () => isUnrestricted() || userPermissions.some((p) => p.endpoint === PermissionConfig.ContractFunctions.RoleCreate);
  const canRemoveRoles = () => isUnrestricted() || userPermissions.some((p) => p.endpoint === PermissionConfig.ContractFunctions.RoleRemove);
  const canAssignRoles = () => isUnrestricted() || userPermissions.some((p) => p.endpoint === PermissionConfig.ContractFunctions.RoleAssign);
  const canUnassignRoles = () => isUnrestricted() || userPermissions.some((p) => p.endpoint === PermissionConfig.ContractFunctions.RoleUnassign);
  const canCreatePermissions = () => isUnrestricted() || userPermissions.some((p) => p.endpoint === PermissionConfig.ContractFunctions.PermissionCreate);
  const canCreatePolicies = () => isUnrestricted() || userPermissions.some((p) => PermissionConfig.PolicySettings.some((s) => s.Function === p.endpoint));
  return {
    isUnrestricted,
    canAddProposalPayment,
    canCallContract,
    canManageUsers,
    canCreateTicket,
    //
    canCreateRoles,
    canRemoveRoles,
    canAssignRoles,
    canUnassignRoles,
    canCreatePermissions,
    canCreatePolicies
  };
};

// src/hooks/useScQuery.ts
import { AbiRegistry, Address, ApiNetworkProvider, SmartContractController } from "@multiversx/sdk-core";
var useScQuery = (network, scInfo, cacheConfig) => {
  const chainApi = new ApiNetworkProvider(network.urls.api, { timeout: 3e4 });
  const shouldCache = !!cacheConfig;
  const getCache = () => {
    if (!cacheConfig) return null;
    const item = sessionStorage.getItem(cacheConfig.key);
    if (item) {
      const cachedData = JSON.parse(item);
      const isExpired = cachedData.timestamp < Date.now() - cacheConfig.ttl * 1e3;
      if (!isExpired) return cachedData.value;
      sessionStorage.removeItem(cacheConfig.key);
    }
    return null;
  };
  const setCache = (value) => {
    if (!cacheConfig) return;
    const cacheData = { value, timestamp: Date.now() };
    sessionStorage.setItem(cacheConfig.key, JSON.stringify(cacheData));
  };
  const _getAbiJsonContent = async () => {
    if (scInfo.AbiContent) return scInfo.AbiContent;
    const abiRes = await fetch(scInfo.AbiUrl);
    return await abiRes.json();
  };
  const query = async (args = [], caller) => {
    if (shouldCache) {
      const cachedResponse = getCache();
      if (cachedResponse) return cachedResponse;
    }
    const abiJsonContent = await _getAbiJsonContent();
    const abi = AbiRegistry.create(abiJsonContent);
    const controller = new SmartContractController({ chainID: network.chainId, networkProvider: chainApi, abi });
    const contract = Address.newFromBech32(scInfo.Address);
    const callerAddress = caller ? Address.newFromBech32(caller) : void 0;
    const response = await controller.query({ contract, function: scInfo.Endpoint, arguments: args, caller: callerAddress });
    if (shouldCache) setCache(response);
    return response;
  };
  return { query };
};
export {
  useDebounce,
  useDidMountEffect,
  usePermission,
  useScQuery
};