player-map 2.0.20 → 2.0.22

package/dist/components/vote/voteUtils.d.ts

@@ -0,0 +1,49 @@
+import { VoteItem, VoteDirection } from '../../types/vote';
+import { Network } from '../../hooks/useAtomData';
+import { TripleDetails } from '../../hooks/useFetchTripleDetails';
+
+interface LoadingProgress {
+    loaded: number;
+    total: number;
+}
+export declare const useVoteFetchTripleDetails: (network?: Network) => {
+    fetchTripleDetails: (tripleId: string) => Promise<TripleDetails | null>;
+    isLoading: boolean;
+};
+export declare const useVoteDisplayTriplesWithPosition: (walletAddress: string) => {
+    data: any;
+    loading: boolean;
+    error: Error | null;
+};
+export declare const useVoteItemsManagementOptimized: ({ network, walletAddress, onError, }: {
+    network?: Network;
+    walletAddress?: string;
+    onError?: (message: string) => void;
+}) => {
+    voteItems: VoteItem[];
+    setVoteItems: import('react').Dispatch<import('react').SetStateAction<VoteItem[]>>;
+    isLoading: boolean;
+    isFullyLoaded: boolean;
+    loadingProgress: LoadingProgress;
+    totalUnits: number;
+    numberOfTransactions: number;
+    handleChangeUnits: (id: bigint, direction: VoteDirection, units: number) => void;
+    resetAllVotes: () => void;
+    loadTripleDetails: () => Promise<void>;
+    isVoteDirectionAllowed: (tripleId: bigint, direction: VoteDirection) => boolean;
+    userPositions: Record<string, VoteDirection>;
+};
+export declare const clearVoteCaches: () => void;
+export declare const getVoteCacheStats: () => {
+    tripleCache: {
+        size: number;
+        maxSize: number;
+        ttl: number;
+    };
+    userPositionsCache: {
+        size: number;
+        maxSize: number;
+        ttl: number;
+    };
+};
+export {};

package/dist/config/atomFiltering.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Filtre l'image d'un atome en fonction de son statut de vérification
+ * Si l'atome est non-vérifiés, remplace l'image par un carré vert
+ */
+export declare const filterAtomImage: (atom: any) => any;
+/**
+ * Filtre les images dans un triple (subject et object)
+ */
+export declare const filterTripleImages: (triple: any) => any;
+/**
+ * Filtre les images dans un tableau de triples
+ */
+export declare const filterTriplesImages: (triples: any[]) => any[];
+/**
+ * Filtre les images dans un tableau d'atomes
+ */
+export declare const filterAtomsImages: (atoms: any[]) => any[];

package/dist/config/graphql.d.ts

@@ -0,0 +1 @@
+export default function initGraphql(): void;

package/dist/config/verifiedAtoms.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Configuration des atomes vérifiés par les studios
+ * Les atomes dans cette liste affichent l'image avec un badge de vérification
+ * Format: { atomId: studioName }
+ */
+export declare const VERIFIED_ATOMS: Record<string, string>;
+/**
+ * Configuration des atomes non vérifiés (créés par la communauté)
+ * Les atomes dans cette liste n'affichent PAS l'image et affichent un avertissement
+ * Format: { atomId: reason }
+ */
+export declare const NOT_VERIFIED_ATOMS: Record<string, string>;
+/**
+ * Image de remplacement : carré vert pour les atomes non-vérifiés
+ */
+export declare const GREEN_SQUARE_PLACEHOLDER = "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' width='100' height='100'%3E%3Crect width='100' height='100' fill='%2322c55e'/%3E%3C/svg%3E";
+/**
+ * Vérifier le statut de vérification d'un atome
+ * Retourne: "verified" | "not-verified" | "normal" (comportement par défaut)
+ */
+export declare const getAtomVerificationStatus: (atomId?: string) => {
+    status: "verified" | "not-verified" | "normal";
+    studio?: string;
+};

package/dist/contexts/GameContext.d.ts

@@ -0,0 +1,35 @@
+import { default as React } from 'react';
+import { GameConfig } from '../types/PlayerMapConfig';
+
+export interface ResolvedClaim {
+    atomId: string;
+    label: string;
+    imageUrl?: string;
+    category?: string;
+}
+export interface ResolvedGuild {
+    atomId: string;
+    label: string;
+}
+export interface ResolvedGame {
+    atomId: string;
+    label: string;
+    imageUrl?: string;
+    claims: ResolvedClaim[];
+    guilds: ResolvedGuild[];
+}
+export interface GameContextValue {
+    games: ResolvedGame[];
+    activeGame: ResolvedGame | null;
+    setActiveGameId: (atomId: string) => void;
+    isLoading: boolean;
+}
+interface GameContextProviderProps {
+    games: GameConfig[];
+    activeGameId?: string;
+    onGameChange?: (atomId: string) => void;
+    children: React.ReactNode;
+}
+export declare const GameContextProvider: React.FC<GameContextProviderProps>;
+export declare function useGameContext(): GameContextValue;
+export {};

package/dist/contexts/QueryClientContext.d.ts

@@ -0,0 +1,9 @@
+import { default as React, ReactNode } from 'react';
+import { QueryClient } from '@tanstack/react-query';
+
+interface QueryClientProviderProps {
+    children: ReactNode;
+}
+export declare const PlayerMapQueryClientProvider: React.FC<QueryClientProviderProps>;
+export declare const useQueryClientContext: () => QueryClient;
+export {};

package/dist/hooks/useAtomCreation.d.ts

@@ -0,0 +1,25 @@
+export type IpfsAtomInput = {
+    name: string;
+    description?: string;
+    image?: string | undefined;
+};
+export interface UseAtomCreationProps {
+    walletConnected?: any;
+    walletAddress?: string;
+    publicClient?: any;
+}
+export declare const useAtomCreation: ({ walletConnected, walletAddress, publicClient }: UseAtomCreationProps) => {
+    createAtom: (input: IpfsAtomInput) => Promise<{
+        atomId: bigint;
+        ipfsHash: string;
+    }>;
+    createStringAtom: (str: string) => Promise<{
+        atomId: bigint;
+    }>;
+    createEthereumAccountAtom: (address: string) => Promise<{
+        atomId: bigint;
+    }>;
+    createConsentAtom: (consentJson: object) => Promise<{
+        atomId: bigint;
+    }>;
+};

package/dist/hooks/useAtomData.d.ts

@@ -0,0 +1,11 @@
+import { createServerClient } from '@0xintuition/graphql';
+
+export declare enum Network {
+    MAINNET = "mainnet",
+    TESTNET = "testnet"
+}
+export declare const API_URLS: {
+    mainnet: string;
+    testnet: string;
+};
+export declare const createClient: (network?: Network) => ReturnType<typeof createServerClient>;

package/dist/hooks/useAtomLabel.d.ts

@@ -0,0 +1,7 @@
+import { Network } from './useAtomData';
+
+/**
+ * Fetches the label of an atom by its ID from the indexer.
+ * Used to display dynamic names (e.g. game name) without hardcoding.
+ */
+export declare const useAtomLabel: (atomId: string | undefined, network?: Network, fallback?: string) => string;

package/dist/hooks/useBatchCreateTriple.d.ts

@@ -0,0 +1,16 @@
+export interface TripleToCreate {
+    subjectId: bigint;
+    predicateId: bigint;
+    objectId: bigint;
+}
+interface UseBatchCreateTripleProps {
+    walletConnected?: any;
+    walletAddress?: string;
+    publicClient?: any;
+}
+export declare const useBatchCreateTriple: ({ walletConnected, walletAddress, publicClient }: UseBatchCreateTripleProps) => {
+    checkTripleExists: (subjectId: bigint, predicateId: bigint, objectId: bigint) => Promise<boolean>;
+    batchCreateTriple: (triples: TripleToCreate[]) => Promise<any>;
+    computeTripleId: (subjectId: bigint, predicateId: bigint, objectId: bigint) => Promise<bigint>;
+};
+export {};

package/dist/hooks/useCheckSpecificTriplePosition.d.ts

@@ -0,0 +1,16 @@
+import { Network } from './useAtomData';
+
+interface UseCheckSpecificTriplePositionProps {
+    walletAddress: string;
+    tripleId: string | number;
+    network?: Network;
+}
+export declare const useCheckSpecificTriplePosition: ({ walletAddress, tripleId, network }: UseCheckSpecificTriplePositionProps) => {
+    hasPosition: boolean;
+    isFor: boolean | null;
+    loading: boolean;
+    error: Error | null;
+    termPositionCount: number;
+    counterTermPositionCount: number;
+};
+export {};

package/dist/hooks/useClaimsBySubject.d.ts

@@ -0,0 +1,7 @@
+import { Network } from './useAtomData';
+
+export declare const useClaimsBySubject: (subjectId: string | undefined, network?: Network) => {
+    claims: any[];
+    loading: boolean;
+    error: Error | null;
+};

package/dist/hooks/useCreateAlias.d.ts

@@ -0,0 +1,17 @@
+import { AliasCreationStep } from '../types/alias';
+
+interface UseCreateAliasProps {
+    walletConnected?: any;
+    walletAddress?: string;
+    publicClient?: any;
+    playerAtomId: string | null;
+}
+export declare const useCreateAlias: ({ walletConnected, walletAddress, publicClient, playerAtomId, }: UseCreateAliasProps) => {
+    createAlias: (pseudo: string) => Promise<void>;
+    reset: () => void;
+    step: AliasCreationStep;
+    isCreating: boolean;
+    error: string | undefined;
+    pseudoAtomId: string | undefined;
+};
+export {};

package/dist/hooks/useDepositTriple.d.ts

@@ -0,0 +1,18 @@
+import { VoteDirection, DepositResponse } from '../types/vote';
+import { Network } from './useAtomData';
+
+interface UseDepositTripleProps {
+    walletConnected?: any;
+    walletAddress?: string;
+    publicClient?: any;
+    network?: Network;
+}
+export declare const useDepositTriple: ({ walletConnected, walletAddress, publicClient, network, }: UseDepositTripleProps) => {
+    depositTriple: (votes: Array<{
+        claimId: string;
+        units: number;
+        direction: VoteDirection;
+    }>) => Promise<DepositResponse>;
+    isLoading: boolean;
+};
+export {};

package/dist/hooks/useDisplayTriplesWithPosition.d.ts

@@ -0,0 +1,5 @@
+export declare const useDisplayTriplesWithPosition: (walletAddress: string) => {
+    data: any;
+    loading: boolean;
+    error: Error | null;
+};

package/dist/hooks/useFetchTripleDetails.d.ts

@@ -0,0 +1,36 @@
+import { Network } from './useAtomData';
+
+export interface TripleDetails {
+    id: string;
+    subject?: {
+        term_id: string;
+        label: string;
+        image?: string;
+    };
+    predicate?: {
+        term_id: string;
+        label: string;
+    };
+    object?: {
+        term_id: string;
+        label: string;
+    };
+    term_id?: string;
+    term_position_count?: number;
+    counter_term_id?: string;
+    counter_term_position_count?: number;
+}
+interface UseFetchTripleDetailsProps {
+    network?: Network;
+    onError?: (message: string) => void;
+}
+export declare const useFetchTripleDetails: ({ network, onError }?: UseFetchTripleDetailsProps) => {
+    fetchTripleDetails: (tripleId: string) => Promise<TripleDetails | null>;
+    isLoading: boolean;
+};
+export declare const useTripleDetails: (tripleId: string | undefined, network?: Network) => {
+    tripleDetails: TripleDetails | null;
+    loading: boolean;
+    error: Error | null;
+};
+export {};

package/dist/hooks/useGameStats.d.ts

@@ -0,0 +1,14 @@
+import { Network } from './useAtomData';
+
+export interface GameStats {
+    gameName: string;
+    gameImage: string | null;
+    gameTermId: string | null;
+    totalGuilds: number;
+    totalPlayers: number;
+    totalVotes: number;
+    totalAttestations: number;
+    loading: boolean;
+    error: string | null;
+}
+export declare const useGameStats: (network?: Network) => GameStats;

package/dist/hooks/usePlayerAliases.d.ts

@@ -0,0 +1,15 @@
+import { Network } from './useAtomData';
+import { PlayerAlias } from '../types/alias';
+
+interface UsePlayerAliasesProps {
+    walletAddress?: string;
+    network?: Network;
+}
+export declare const usePlayerAliases: ({ walletAddress, network, }: UsePlayerAliasesProps) => {
+    aliases: PlayerAlias[];
+    primaryAlias: PlayerAlias | null;
+    playerAtomId: string | null;
+    isLoading: boolean;
+    error: Error | null;
+};
+export {};

package/dist/hooks/usePositions.d.ts

@@ -0,0 +1,7 @@
+import { Network } from './useAtomData';
+
+export declare const usePositions: (accountId: string | undefined, network?: Network) => {
+    positions: any[];
+    loading: boolean;
+    error: Error | null;
+};

package/dist/hooks/useRedeemAmounts.d.ts

@@ -0,0 +1,7 @@
+export declare const useRedeemAmounts: () => {
+    selectedPositions: Set<string>;
+    redeemAmounts: Record<string, number>;
+    handlePositionSelect: (positionId: string, selected: boolean) => void;
+    handleAmountChange: (positionId: string, amount: number) => void;
+    clearSelection: () => void;
+};

package/dist/hooks/useRedeemBatch.d.ts

@@ -0,0 +1,19 @@
+interface RedeemBatchParams {
+    receiver: `0x${string}`;
+    termIds: `0x${string}`[];
+    curveIds: bigint[];
+    shares: bigint[];
+    minAssets: bigint[];
+}
+interface UseRedeemBatchProps {
+    walletConnected?: any;
+    walletAddress?: string;
+}
+export declare const useRedeemBatch: ({ walletConnected, walletAddress, }: UseRedeemBatchProps) => {
+    redeemBatch: (params: RedeemBatchParams) => Promise<{
+        success: boolean;
+        hash: any;
+    }>;
+    isLoading: boolean;
+};
+export {};

package/dist/hooks/useRedeemExecution.d.ts

@@ -0,0 +1,15 @@
+interface UseRedeemExecutionProps {
+    walletConnected?: any;
+    walletAddress?: string;
+}
+export declare const useRedeemExecution: ({ walletConnected, walletAddress }: UseRedeemExecutionProps) => {
+    handleRedeemAllSelected: (positions: any[], selectedPositions: Set<string>, redeemAmounts: Record<string, number>, accountId: string) => Promise<{
+        success: boolean;
+        error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+    } | undefined>;
+    isLoading: boolean;
+};
+export {};

package/dist/hooks/useRegisterPlayer.d.ts

@@ -0,0 +1,40 @@
+import { Network } from './useAtomData';
+import { IdentityCreationStep } from '../types/alias';
+
+interface UseRegisterPlayerProps {
+    walletConnected?: any;
+    walletAddress?: string;
+    publicClient?: any;
+    network?: Network;
+    guildId?: string;
+    existingAccountAtomId?: string;
+    existingPseudoAtomId?: string;
+    existingAliasTripleId?: string;
+    consentAlreadyAccepted?: boolean;
+    chainId?: number;
+}
+/**
+ * Phase 1 registration hook.
+ *
+ * Creates the player's identity via up to four sequential on-chain operations:
+ *   1. createStringAtom(pseudo)               → pseudoAtomId
+ *   2. getOrCreate account atom(walletAddress) → accountAtomId
+ *   3. createTriple([accountAtom, HAS_ALIAS, pseudoAtom]) → aliasTripleId
+ *   4. (if guildId) createTriple([aliasTripleId, IS_MEMBER_OF, guildAtomId])
+ *
+ * Retry-safe: pseudoAtomId and accountAtomId are preserved in state on error
+ * so that a retry call to register(pseudo) skips already-completed steps.
+ *
+ * Call reset() only to explicitly cancel the flow (clears all preserved IDs).
+ */
+export declare const useRegisterPlayer: ({ walletConnected, walletAddress, publicClient, network, guildId, existingAccountAtomId, existingPseudoAtomId, existingAliasTripleId, consentAlreadyAccepted, chainId, }: UseRegisterPlayerProps) => {
+    register: (pseudo: string, imageFile?: File) => Promise<void>;
+    reset: () => void;
+    step: IdentityCreationStep;
+    isRegistering: boolean;
+    error: string | undefined;
+    pseudoAtomId: string | undefined;
+    accountAtomId: string | undefined;
+    aliasTripleId: string | undefined;
+};
+export {};

package/dist/hooks/useSelectedAtomClaims.d.ts

@@ -0,0 +1,9 @@
+import { Network } from './useAtomData';
+
+interface SelectedAtomClaims {
+    claims: any[];
+    loading: boolean;
+    error: string | null;
+}
+export declare const useSelectedAtomClaims: (selectedNode: any, network?: Network) => SelectedAtomClaims;
+export {};

package/dist/hooks/useSelectedAtomData.d.ts

@@ -0,0 +1,10 @@
+import { Network } from './useAtomData';
+import { AtomDetails } from '../api/fetchAtomDetails';
+
+interface SelectedAtomData {
+    atomDetails: AtomDetails | null;
+    loading: boolean;
+    error: string | null;
+}
+export declare const useSelectedAtomData: (selectedNode: any, network?: Network) => SelectedAtomData;
+export {};

package/dist/hooks/useSidebarData.d.ts

@@ -0,0 +1,16 @@
+import { Network } from './useAtomData';
+
+interface SidebarData {
+    atomDetails: any | null;
+    triples: any[];
+    positions: any[];
+    activities: any[];
+    connections: {
+        follows: any[];
+        followers: any[];
+    };
+    loading: boolean;
+    error: string | null;
+}
+export declare const useSidebarData: (walletAddress: string | undefined, network?: Network) => SidebarData;
+export {};

package/dist/hooks/useSubmitVotes.d.ts

@@ -0,0 +1,22 @@
+import { VoteItem, DepositResponse } from '../types/vote';
+import { Network } from './useAtomData';
+
+type TransactionStatus = {
+    status: "idle" | "pending" | "success" | "error" | "approval_pending" | "whitelist_error";
+    message: string;
+};
+interface UseSubmitVotesProps {
+    walletConnected?: any;
+    walletAddress?: string;
+    publicClient?: any;
+    network?: Network;
+    onSuccess?: () => void;
+}
+export declare const useSubmitVotes: ({ walletConnected, walletAddress, publicClient, network, onSuccess }: UseSubmitVotesProps) => {
+    submitVotes: (voteItems: VoteItem[]) => Promise<DepositResponse | null>;
+    isSubmitting: boolean;
+    isDepositLoading: boolean;
+    transactionStatus: TransactionStatus;
+    setTransactionStatus: import('react').Dispatch<import('react').SetStateAction<TransactionStatus>>;
+};
+export {};

package/dist/hooks/useTripleByCreator.d.ts

@@ -0,0 +1,54 @@
+import { Network } from './useAtomData';
+
+export interface Triple {
+    term_id: string;
+    subject_id: string;
+    predicate_id: string;
+    object_id: string;
+    subject: {
+        term_id: string;
+        label: string;
+        type: string;
+        creator_id: string;
+        image?: string;
+        value?: {
+            person?: {
+                description: string;
+            };
+            organization?: {
+                description: string;
+            };
+            thing?: {
+                description: string;
+            };
+            book?: {
+                description: string;
+            };
+        };
+    };
+    predicate: {
+        term_id: string;
+        label: string;
+        type: string;
+    };
+    object: {
+        term_id: string;
+        label: string;
+        type: string;
+    };
+    block_number: number;
+    created_at: string;
+    transaction_hash: string;
+}
+export interface TriplesByCreatorResponse {
+    triples: Triple[];
+}
+export declare const fetchTriplesByCreator: (creatorId: string, predicateId: string, objectId: string, network?: Network) => Promise<TriplesByCreatorResponse>;
+export declare const useTripleByCreator: (creatorId: string, predicateId?: string, objectId?: string, network?: Network) => {
+    loading: boolean;
+    error: Error | null;
+    triples: Triple[];
+    network: Network;
+    rawData: TriplesByCreatorResponse | undefined;
+};
+export default useTripleByCreator;

package/dist/hooks/useVoteItemsManagement.d.ts

@@ -0,0 +1,22 @@
+import { VoteItem, VoteDirection } from '../types/vote';
+import { Network } from './useAtomData';
+
+interface UseVoteItemsManagementProps {
+    network?: Network;
+    walletAddress?: string;
+    onError?: (message: string) => void;
+}
+export declare const useVoteItemsManagement: ({ network, walletAddress, onError, }: UseVoteItemsManagementProps) => {
+    voteItems: VoteItem[];
+    setVoteItems: import('react').Dispatch<import('react').SetStateAction<VoteItem[]>>;
+    isLoading: boolean;
+    totalUnits: number;
+    numberOfTransactions: number;
+    handleChangeUnits: (id: bigint, direction: VoteDirection, units: number) => void;
+    resetAllVotes: () => void;
+    refreshPositions: () => void;
+    loadTripleDetails: (currentUserPositions?: Record<string, VoteDirection>) => Promise<void>;
+    isVoteDirectionAllowed: (tripleId: bigint, direction: VoteDirection) => boolean;
+    userPositions: Record<string, VoteDirection>;
+};
+export {};

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+import { default as PlayerMapHome } from './PlayerMapHome';
+import { default as PlayerMapGraph } from './PlayerMapGraph';
+import { default as GraphComponent } from './GraphComponent';
+import { ClaimVoting } from './components/vote/ClaimVoting';
+import { default as VotingModal } from './components/vote/VotingModal';
+import { useDepositTriple } from './hooks/useDepositTriple';
+import { useCheckSpecificTriplePosition } from './hooks/useCheckSpecificTriplePosition';
+import { useDisplayTriplesWithPosition } from './hooks/useDisplayTriplesWithPosition';
+import { usePositions } from './hooks/usePositions';
+import { useClaimsBySubject } from './hooks/useClaimsBySubject';
+import { checkTriplePosition } from './utils/debugPosition';
+import { setPinataConstants } from './utils/globalConstants';
+
+export interface PlayerMapConfigType {
+    apiUrl: string;
+}
+export { PlayerMapHome, PlayerMapGraph, GraphComponent, ClaimVoting, VotingModal, useDepositTriple, useCheckSpecificTriplePosition, useDisplayTriplesWithPosition, usePositions, useClaimsBySubject, checkTriplePosition, };
+export { VoteDirection, type Claim, type VoteItem, type DepositResponse } from './types/vote';
+export { UNIT_VALUE, PREDICATES } from './utils/constants';
+export declare const PlayerMapConfig: {
+    /**
+     * Initialise la configuration de la bibliothèque Player-map
+     * @param config Configuration contenant l'URL de l'API (obligatoire)
+     */
+    init: (config: PlayerMapConfigType) => boolean;
+    /**
+     * Récupère la configuration actuelle
+     * @throws Error si la configuration n'a pas été initialisée
+     */
+    get: () => Readonly<import('./utils/config').IPlayerMapConfig>;
+};
+export { setPinataConstants };
+export { usePlayerAliases } from './hooks/usePlayerAliases';
+export { useCreateAlias } from './hooks/useCreateAlias';
+export { useRegisterPlayer } from './hooks/useRegisterPlayer';
+export type { PlayerAlias, AliasCreationStep, RegistrationPhase, IdentityCreationStep, InitItem } from './types/alias';
+export { default as PlayerMap } from './PlayerMap';
+export { GameContextProvider, useGameContext } from './contexts/GameContext';
+export type { ResolvedGame, ResolvedClaim, ResolvedGuild, GameContextValue } from './contexts/GameContext';
+export type { GameConfig, ClaimConfig, GuildConfig, PlayerMapProps } from './types/PlayerMapConfig';
+export default PlayerMapHome;