@apollion-dsi/relay 0.27.2 → 0.28.0

package/lib/setupRelayEnvironment/setupRelayEnvironment.d.ts

@@ -4,22 +4,22 @@ declare const kMountEnvironment: unique symbol;
 declare const kFeetchHandler: unique symbol;
 declare const kSubscriptionHandler: unique symbol;
 /**
- * Fábrica de `Environment` Relay com bateria inclusa: autenticação JWT,
- * retries com backoff, suporte a subscriptions via WebSocket, cache de
- * respostas e estratégia plugável de storage (localStorage ou cookie).
+ * Batteries-included Relay `Environment` factory: JWT authentication,
+ * retries with backoff, subscription support via WebSocket, response
+ * caching and a pluggable storage strategy (localStorage or cookie).
  *
- * Esta classe encapsula a configuração que normalmente precisaria ser
- * escrita à mão para cada projeto que usa Relay: criar `Network`,
- * `RecordSource`, `Store`, configurar `fetch` com retries/timeout,
- * adicionar headers de autenticação, lidar com redirecionamento em caso
- * de sessão expirada e opcionalmente registrar um handler de
- * subscriptions GraphQL.
+ * This class encapsulates the configuration that would normally have to be
+ * written by hand for every project using Relay: creating `Network`,
+ * `RecordSource`, `Store`, configuring `fetch` with retries/timeout,
+ * adding authentication headers, handling redirection when the
+ * session expires and optionally registering a GraphQL
+ * subscriptions handler.
  *
- * A instância exposta possui a propriedade pública `Environment`, que é
- * o objeto que deve ser passado para `react-relay` (via `RelayEnvironmentProvider`
- * ou `QueryRenderer`).
+ * The exposed instance has the public `Environment` property, which is
+ * the object that must be passed to `react-relay` (via `RelayEnvironmentProvider`
+ * or `QueryRenderer`).
  *
- * @example Setup mínimo
+ * @example Minimal setup
  * ```ts
  * import { CreateRelayEnvironment } from '@apollion-dsi/relay';
  *
@@ -28,7 +28,7 @@ declare const kSubscriptionHandler: unique symbol;
  * });
  * ```
  *
- * @example Com auth JWT (Bearer) e retries
+ * @example With JWT (Bearer) auth and retries
  * ```ts
  * const { Environment } = new CreateRelayEnvironment({
  *   url: 'https://api.example.com/graphql/',
@@ -39,12 +39,12 @@ declare const kSubscriptionHandler: unique symbol;
  * });
  * ```
  *
- * @example Com sessão por cookie httpOnly (modelo seguro p/ SPA)
+ * @example With httpOnly cookie session (secure model for SPAs)
  * ```ts
- * // O token de sessão fica num cookie httpOnly + SameSite (invisível ao
- * // JS, imune a XSS). Nada é lido do storage e nenhum Bearer é injetado;
- * // `credentials:'include'` faz o browser anexar o cookie sozinho. Em
- * // erro de auth (401) o refresh é disparado contra `authUrl`.
+ * // The session token lives in an httpOnly + SameSite cookie (invisible to
+ * // JS, immune to XSS). Nothing is read from storage and no Bearer is injected;
+ * // `credentials:'include'` makes the browser attach the cookie on its own. On
+ * // an auth error (401) the refresh is dispatched against `authUrl`.
  * const { Environment } = new CreateRelayEnvironment({
  *   url: 'https://api.example.com/graphql/',
  *   authUrl: 'https://api.example.com/auth/refresh/',
@@ -54,7 +54,7 @@ declare const kSubscriptionHandler: unique symbol;
  * });
  * ```
  *
- * @example Com subscriptions
+ * @example With subscriptions
  * ```ts
  * const { Environment } = new CreateRelayEnvironment({
  *   url: 'https://api.example.com/graphql/',
@@ -63,86 +63,103 @@ declare const kSubscriptionHandler: unique symbol;
  * });
  * ```
  *
- * @see {@link RelayArgsInterface} para a lista completa de opções de configuração.
+ * @example With persisted queries (server-aligned hash allowlist)
+ * ```ts
+ * // Requires `persistConfig` in the consumer's relay.config.json, e.g.
+ * // { "persistConfig": { "file": "./persisted/queryMap.json", "algorithm": "MD5" } }.
+ * // The request body becomes `{ name, doc_id, variables }` — the GraphQL
+ * // text never leaves the build; the server resolves the hash against the
+ * // query map and refuses anything else.
+ * const { Environment } = new CreateRelayEnvironment({
+ *   url: 'https://api.example.com/graphql/',
+ *   usePersistedQueries: true,
+ * });
+ * ```
+ *
+ * @see {@link RelayArgsInterface} for the complete list of configuration options.
  */
 export default class RelayEnvironment implements RelayArgsInterface {
-    /** Endpoint HTTP do servidor GraphQL. Obrigatório. */
+    /** HTTP endpoint of the GraphQL server. Required. */
     url: string;
-    /** Endpoint do servidor de autenticação. Obrigatório quando `useAuthorization` é `true`. */
+    /** Authentication server endpoint. Required when `useAuthorization` is `true`. */
     authUrl?: string;
-    /** Endpoint WebSocket para subscriptions. Obrigatório quando `useSubscription` é `true`. */
+    /** WebSocket endpoint for subscriptions. Required when `useSubscription` is `true`. */
     socket?: string;
-    /** Lista de delays (ms) entre tentativas, quando `useRetries` é `true`. */
+    /** List of delays (ms) between attempts, when `useRetries` is `true`. */
     retries?: number[];
-    /** Timeout (ms) por requisição. */
+    /** Per-request timeout (ms). */
     timeout?: number;
-    /** Habilita subscriptions GraphQL via WebSocket. */
+    /** Enables GraphQL subscriptions over WebSocket. */
     useSubscription?: boolean;
-    /** Habilita injeção do header `Authorization: Bearer <token>` em cada request. */
+    /** Enables injecting the `Authorization: Bearer <token>` header on every request. */
     useAuthorization?: boolean;
-    /** Modelo de auth: `'bearer'` (token JS + header) ou `'cookie'` (httpOnly). */
+    /** Auth model: `'bearer'` (JS token + header) or `'cookie'` (httpOnly). */
     authMode: 'bearer' | 'cookie';
-    /** Valor de `credentials` repassado aos fetches GraphQL/refresh. */
+    /** `credentials` value forwarded to the GraphQL/refresh fetches. */
     credentials?: RequestCredentials;
-    /** URL de verificação/refresh de sessão; `false` desliga o probe. */
+    /** Session verification/refresh URL; `false` disables the probe. */
     sessionCheckUrl?: string | false;
-    /** Habilita cache de respostas (via `QueryResponseCache` do Relay). */
+    /** Enables response caching (via Relay's `QueryResponseCache`). */
     useCache?: boolean;
-    /** TTL (ms) das entradas do cache. */
+    /** TTL (ms) of the cache entries. */
     cacheTime?: number;
-    /** Tamanho máximo do cache (número de queries). */
+    /** Maximum cache size (number of queries). */
     cacheSize?: number;
-    /** Nome da chave em storage usada para guardar o token de sessão. */
+    /** Storage key name used to hold the session token. */
     sessionStorageProp?: string;
-    /** Nome da chave em storage usada para guardar o refresh token. */
+    /** Storage key name used to hold the refresh token. */
     refreshStorageProp?: string;
-    /** Rota usada para redirecionar o usuário em caso de sessão expirada. */
+    /** Route used to redirect the user when the session expires. */
     loginRoute?: string;
-    /** Liga logs de debug (útil em desenvolvimento). */
+    /** Turns on debug logs (useful in development). */
     useDebug?: boolean;
-    /** Habilita o mecanismo de retries em caso de erro/timeout. */
+    /** Enables the retry mechanism on error/timeout. */
     useRetries?: boolean;
-    /** Redireciona automaticamente para `loginRoute` em caso de erro de auth. */
+    /** Automatically redirects to `loginRoute` on an auth error. */
     redirectOnError?: boolean;
-    /** Lista de status HTTP que disparam retry (quando `useRetries` é `true`). */
+    /** List of HTTP statuses that trigger a retry (when `useRetries` is `true`). */
     retryWhen?: number[];
-    /** Status HTTP considerados como erros de autenticação (default: 401, 403). */
+    /** HTTP statuses treated as authentication errors (default: 401, 403). */
     authenticationErrors?: number[];
-    /** Estratégia de storage no browser. */
+    /** Browser storage strategy. */
     storageType: 'cookie' | 'localStorage';
-    /** Identificador opcional do parceiro, enviado no header `X-Partner`. */
+    /** Optional partner identifier, sent in the `X-Partner` header. */
     partner?: string;
+    /** Sends only the build-time operation hash instead of the GraphQL text. */
+    usePersistedQueries?: boolean;
+    /** Request field carrying the persisted-operation hash. */
+    persistedOperationField?: string;
     /**
-     * Função de fetch montada para uso pelo `Network` do Relay. Interno.
+     * Fetch function assembled for use by Relay's `Network`. Internal.
      */
     private [kFeetchHandler]?;
     /**
-     * Função de subscription montada para uso pelo `Network` do Relay. Interno.
+     * Subscription function assembled for use by Relay's `Network`. Internal.
      */
     private [kSubscriptionHandler]?;
     /**
-     * Handler de storage. Expõe métodos `getTokens`, `setTokens`, `clear`,
-     * `hasChangedSession`. Use diretamente quando precisar manipular tokens
-     * fora do fluxo padrão (ex: tela de login).
+     * Storage handler. Exposes the `getTokens`, `setTokens`, `clear`,
+     * `hasChangedSession` methods. Use it directly when you need to manipulate
+     * tokens outside the standard flow (e.g. a login screen).
      */
     StorageHandler: any;
     /**
-     * Instância de `Environment` do `relay-runtime` pronta para uso com
+     * `relay-runtime` `Environment` instance ready for use with
      * `RelayEnvironmentProvider` (`react-relay`).
      */
     Environment: Environment;
     /**
-     * @param config - Configuração da instância. Veja {@link RelayArgsInterface}.
-     * Apenas `url` é obrigatório; demais opções têm defaults sensatos.
+     * @param config - Instance configuration. See {@link RelayArgsInterface}.
+     * Only `url` is required; the other options have sensible defaults.
      *
-     * @throws {Error} Se `url` não for informado.
-     * @throws {Error} Se `useAuthorization` for `true` e `authUrl` não for informado.
-     * @throws {Error} Se `useSubscription` for `true` e `socket` não for informado.
+     * @throws {Error} If `url` is not provided.
+     * @throws {Error} If `useAuthorization` is `true` and `authUrl` is not provided.
+     * @throws {Error} If `useSubscription` is `true` and `socket` is not provided.
      */
     constructor(config: RelayArgsInterface);
     /**
-     * Monta o `Environment` Relay a partir da fetch function e subscription
-     * handler configurados. Chamado uma única vez pelo construtor.
+     * Assembles the Relay `Environment` from the configured fetch function and
+     * subscription handler. Called exactly once by the constructor.
      */
     private [kMountEnvironment];
 }

package/lib/setupRelayEnvironment/setupRelayEnvironment.helpers.d.ts

@@ -1,98 +1,106 @@
 /**
- * @fileoverview Helpers internos usados por `setupRelayEnvironment` para
- * montar a Network do Relay: detecção do tipo de operação, construção do
- * body/headers da requisição, parse de respostas (incluindo
- * `multipart/mixed` para `@defer`/`@stream`), redirecionamento em erro
- * de auth e constantes de tempo.
+ * @fileoverview Internal helpers used by `setupRelayEnvironment` to
+ * assemble the Relay Network: operation-kind detection, request
+ * body/header construction, response parsing (including
+ * `multipart/mixed` for `@defer`/`@stream`), redirection on auth
+ * error and time constants.
  *
- * Não exposto pelo barrel raiz — faz parte da implementação interna de
+ * Not exposed by the root barrel — part of the internal implementation of
  * `CreateRelayEnvironment`.
  */
 import { CacheConfig, RequestParameters, UploadableMap, Variables } from 'relay-runtime';
 import { RelayArgsInterface, Sink } from '../relayArgsInterface';
-/** Verdadeiro se a operação Relay é uma mutation. */
+/** True if the Relay operation is a mutation. */
 export declare const isMutation: (request: RequestParameters) => boolean;
-/** Verdadeiro se a operação Relay é uma query. */
+/** True if the Relay operation is a query. */
 export declare const isQuery: (request: RequestParameters) => boolean;
-/** Verdadeiro quando o consumidor pediu `force: true` no `CacheConfig` (bypass do cache). */
+/** True when the consumer requested `force: true` in the `CacheConfig` (cache bypass). */
 export declare const forceFetch: (cacheConfig: CacheConfig) => boolean;
 /**
- * Retorna o delimitador (`?` ou `&`) apropriado para anexar query params
- * à URL atual do browser. Retorna string vazia em ambientes sem DOM (SSR).
+ * Returns the appropriate delimiter (`?` or `&`) for appending query params
+ * to the browser's current URL. Returns an empty string in DOM-less environments (SSR).
  */
 export declare const getParamsDelimiter: () => string;
 /**
- * Retorna o `pathname` atual do browser, ou string vazia em ambientes
- * sem DOM (SSR).
+ * Returns the browser's current `pathname`, or an empty string in
+ * DOM-less environments (SSR).
  */
 export declare const getBrowserLocation: () => string;
 /**
- * Redireciona o usuário para `redirectTo`, preservando a URL atual em
- * `?redirect=` (para o fluxo de login redirecionar de volta).
+ * Redirects the user to `redirectTo`, preserving the current URL in
+ * `?redirect=` (so the login flow can redirect back).
  *
- * Não adiciona o parâmetro `redirect` quando a URL atual já é igual ao
- * destino ou quando o destino é a própria `loginRoute`.
+ * Does not add the `redirect` parameter when the current URL already equals
+ * the destination or when the destination is `loginRoute` itself.
  *
- * @param url - URL atual (origem do redirect).
- * @param redirectTo - Destino do redirect.
- * @param config - Configuração do environment (usada para checar `loginRoute`).
+ * @param url - Current URL (redirect origin).
+ * @param redirectTo - Redirect destination.
+ * @param config - Environment configuration (used to check `loginRoute`).
  */
 export declare const redirectUser: (url: string, redirectTo: string, config?: RelayArgsInterface) => void;
+/** Subset of the Environment configuration the body builders read. */
+interface PersistedConfig {
+    usePersistedQueries?: boolean;
+    persistedOperationField?: string;
+}
 /**
- * Constrói o body da requisição GraphQL — multipart se há uploadables,
- * JSON caso contrário.
+ * Builds the GraphQL request body — multipart if there are uploadables,
+ * JSON otherwise.
  *
- * @param request - Parâmetros da requisição Relay.
- * @param variables - Variáveis da operação.
- * @param uploadables - Arquivos para upload (opcional).
+ * @param request - Relay request parameters.
+ * @param variables - Operation variables.
+ * @param uploadables - Files to upload (optional).
+ * @param config - Environment configuration subset for persisted queries
+ *   (optional; absent behaves as `usePersistedQueries: false`).
  */
-export declare function getRequestBody(request: RequestParameters, variables: Variables, uploadables?: UploadableMap): string | FormData;
+export declare function getRequestBody(request: RequestParameters, variables: Variables, uploadables?: UploadableMap, config?: PersistedConfig): string | FormData;
 /**
- * Resolve o valor efetivo de `credentials` para os fetches (GraphQL e
- * verificação/refresh de sessão).
+ * Resolves the effective `credentials` value for the fetches (GraphQL and
+ * session verification/refresh).
  *
- * - Se `config.credentials` foi definido explicitamente, ele vence.
- * - Caso contrário, no modo `authMode:'cookie'` o default é `'include'`
- *   (para o browser anexar cookies httpOnly de sessão).
- * - No modo `'bearer'` (default) retorna `undefined` — o fetch usa o
- *   default do browser, preservando a retrocompat.
+ * - If `config.credentials` was set explicitly, it wins.
+ * - Otherwise, in `authMode:'cookie'` mode the default is `'include'`
+ *   (so the browser attaches httpOnly session cookies).
+ * - In `'bearer'` mode (default) it returns `undefined` — the fetch uses the
+ *   browser default, preserving backwards compatibility.
  *
- * @param config - Configuração do environment.
- * @returns O `RequestCredentials` a usar, ou `undefined` para omitir.
+ * @param config - Environment configuration.
+ * @returns The `RequestCredentials` to use, or `undefined` to omit.
  */
 export declare const resolveCredentials: (config: any) => RequestCredentials | undefined;
 /**
- * Monta os headers HTTP da requisição. Para uploads, usa `Accept: *\/*`
- * e deixa o browser definir o `Content-Type` com boundary. Para JSON,
- * usa `application/json` em ambos.
+ * Assembles the request's HTTP headers. For uploads, uses `Accept: *\/*`
+ * and lets the browser set the `Content-Type` with the boundary. For JSON,
+ * uses `application/json` for both.
  *
- * Modo `bearer` (default): quando `useAuthorization` está ligado e existe
- * um `sessionToken` em storage, anexa `Authorization: Bearer <token>` —
- * exceto quando o usuário está na própria rota de login (para evitar
+ * `bearer` mode (default): when `useAuthorization` is on and a
+ * `sessionToken` exists in storage, attaches `Authorization: Bearer <token>` —
+ * except when the user is on the login route itself (to avoid
  * loops).
  *
- * Modo `cookie` (httpOnly): **nunca** lê o token em JS nem injeta
- * `Authorization` — o cookie de sessão viaja sozinho via `credentials`.
- * Isso evita o header `Authorization: Bearer ` vazio que o modo bearer
- * produziria quando o token é httpOnly e portanto invisível ao JS.
+ * `cookie` mode (httpOnly): **never** reads the token in JS nor injects
+ * `Authorization` — the session cookie travels on its own via `credentials`.
+ * This avoids the empty `Authorization: Bearer ` header that bearer mode
+ * would produce when the token is httpOnly and therefore invisible to JS.
  *
- * Se um `partner` está configurado, adiciona o header `X-Partner`.
+ * If a `partner` is configured, adds the `X-Partner` header.
  */
 export declare const getHeaders: (args: any, uploadables?: UploadableMap) => HeadersInit;
 /**
- * Lê o `Response` do fetch e empurra os dados para o `Sink` do Relay.
+ * Reads the fetch `Response` and pushes the data into the Relay `Sink`.
  *
- * Suporta três modos:
- * - `multipart/mixed` (usado por `@defer` e `@stream`): lê o stream
- *   chunk a chunk e usa `PatchResolver` para repassar cada patch.
- * - `application/json`: parseia o JSON inteiro e chama `callback`.
- * - Outros: lê como texto e empurra como array de strings.
+ * Supports three modes:
+ * - `multipart/mixed` (used by `@defer` and `@stream`): reads the stream
+ *   chunk by chunk and uses `PatchResolver` to forward each patch.
+ * - `application/json`: parses the whole JSON and calls `callback`.
+ * - Others: reads as text and pushes it as an array of strings.
  *
- * Copiado da biblioteca `fetch-multipart-graphql` com adaptações para o
- * `Sink` Relay.
+ * Copied from the `fetch-multipart-graphql` library with adaptations for the
+ * Relay `Sink`.
  */
 export declare const handleData: (response: Response, sink: Sink, callback: (data: any) => void) => void;
-/** Constante de tempo: 1 segundo em milissegundos. */
+/** Time constant: 1 second in milliseconds. */
 export declare const ONE_SECOND = 1000;
-/** Constante de tempo: 1 minuto em milissegundos. */
+/** Time constant: 1 minute in milliseconds. */
 export declare const ONE_MINUTE: number;
+export {};

package/lib/setupRelayEnvironment/storage.d.ts

@@ -1,5 +1,5 @@
 import { RelayArgsInterface } from '../relayArgsInterface';
-/** Par de tokens armazenado. */
+/** Stored token pair. */
 type TokenTypes = {
     sessionToken?: string;
     refreshToken?: string;
@@ -8,9 +8,9 @@ declare const kStorageHandler: unique symbol;
 declare const kPropSession: unique symbol;
 declare const kPropRefresh: unique symbol;
 /**
- * Handler de storage usado por `CreateRelayEnvironment`. Encapsula a
- * estratégia escolhida (`storageType`) e padroniza a manipulação de
- * `sessionToken` e `refreshToken` por trás de uma API estável.
+ * Storage handler used by `CreateRelayEnvironment`. Encapsulates the
+ * chosen strategy (`storageType`) and standardizes the handling of
+ * `sessionToken` and `refreshToken` behind a stable API.
  *
  * @example
  * ```ts
@@ -25,34 +25,34 @@ export default class StorageClass {
     private [kPropSession];
     private [kPropRefresh];
     /**
-     * @param strategy - Instância de `CreateRelayEnvironment` (que
-     *   implementa `RelayArgsInterface`). Os campos lidos são
+     * @param strategy - `CreateRelayEnvironment` instance (which
+     *   implements `RelayArgsInterface`). The fields read are
      *   `storageType`, `sessionStorageProp`, `refreshStorageProp`.
      */
     constructor(strategy: RelayArgsInterface);
     /**
-     * Lê os tokens atualmente armazenados.
+     * Reads the currently stored tokens.
      *
-     * @returns Objeto com `sessionToken` e `refreshToken` (podem ser
-     *   `undefined` quando ausentes).
+     * @returns Object with `sessionToken` and `refreshToken` (may be
+     *   `undefined` when absent).
      */
     getTokens(): TokenTypes;
     /**
-     * Grava ambos os tokens em storage. Use após receber resposta de
-     * login/refresh.
+     * Writes both tokens to storage. Use after receiving a
+     * login/refresh response.
      */
     setTokens(tokens: TokenTypes): void;
     /**
-     * Remove ambos os tokens do storage. Usado em logout ou ao detectar
-     * sessão expirada.
+     * Removes both tokens from storage. Used on logout or when an
+     * expired session is detected.
      */
     clear(): void;
     /**
-     * Compara um novo `sessionToken` com o atualmente armazenado.
+     * Compares a new `sessionToken` against the currently stored one.
      *
-     * @param tokens - Objeto contendo o novo `sessionToken` (vindo, por
-     *   exemplo, de um header de resposta).
-     * @returns `true` se o token mudou.
+     * @param tokens - Object containing the new `sessionToken` (coming, for
+     *   example, from a response header).
+     * @returns `true` if the token changed.
      */
     hasChangedSession({ sessionToken: newSessionToken }: TokenTypes): boolean;
 }

package/lib/setupRelayEnvironment/subscriptionHandler.d.ts

@@ -1,29 +1,35 @@
 /**
- * @fileoverview Fábrica do subscription handler GraphQL via WebSocket,
- * usada por `setupRelayEnvironment` quando `useSubscription` está
- * habilitado.
+ * @fileoverview Factory for the GraphQL subscription handler over WebSocket,
+ * used by `setupRelayEnvironment` when `useSubscription` is
+ * enabled.
  *
- * Baseado em `graphql-ws` (protocolo `graphql-transport-ws`).
+ * Based on `graphql-ws` (`graphql-transport-ws` protocol).
  *
- * Não exposto pelo barrel raiz — implementação interna de
+ * Not exposed by the root barrel — internal implementation of
  * `CreateRelayEnvironment`.
  */
+/** Subset of the Environment configuration the subscription handler reads. */
+interface SubscriptionSettings {
+    socket?: string;
+    usePersistedQueries?: boolean;
+    persistedOperationField?: string;
+}
 /**
- * Monta a subscription function para o `Network.create` do Relay.
+ * Builds the subscription function for Relay's `Network.create`.
  *
- * Retorna uma função (a ser chamada uma vez, no setup do Environment)
- * que por sua vez retorna a subscribe function que o Relay vai invocar
- * para cada subscription operation. A adaptação de callbacks
- * `next/error/complete` do `graphql-ws` para o `Sink` do Observable
- * Relay é feita aqui.
+ * Returns a factory (invoked once, during Environment setup) which yields the
+ * subscribe function Relay calls for each subscription operation. The
+ * `graphql-ws` client is created lazily on the first subscription — no socket
+ * is opened for environments that never subscribe. The adaptation of
+ * `graphql-ws` `next/error/complete` callbacks to the Relay Observable `Sink`
+ * happens here.
  *
- * @param settings - Objeto com a URL do endpoint WebSocket (`socket`).
- *   Quando `useSubscription` é `true` mas `socket` não foi configurado,
- *   o construtor de `CreateRelayEnvironment` lança erro antes desta
- *   função ser chamada.
- * @returns Função que, quando invocada, retorna a subscribe function
- *   compatível com `Network.create(fetchFn, subscribeFn)`.
+ * @param settings - Environment configuration subset: the WebSocket endpoint
+ *   (`socket`) plus the persisted-queries flags. When `useSubscription` is
+ *   `true` but `socket` was not configured, the `CreateRelayEnvironment`
+ *   constructor throws before this function is called.
+ * @returns Factory that, when invoked, returns the subscribe function
+ *   compatible with `Network.create(fetchFn, subscribeFn)`.
  */
-export declare function setupSubscription(settings: {
-    socket?: string;
-}): () => any;
+export declare function setupSubscription(settings: SubscriptionSettings): () => any;
+export {};

package/lib/useEnvironment/index.d.ts

@@ -1,9 +1,9 @@
 /**
- * Barrel público do módulo `useEnvironment`.
+ * Public barrel for the `useEnvironment` module.
  *
- * Reexporta o hook `useEnvironment` e o componente `EnvironmentProvider`,
- * para que consumidores possam importar via
- * `@apollion-dsi/relay/useEnvironment` (granular) ou via
- * `@apollion-dsi/relay` (barrel raiz).
+ * Re-exports the `useEnvironment` hook and the `EnvironmentProvider`
+ * component, so consumers can import via
+ * `@apollion-dsi/relay/useEnvironment` (granular) or via
+ * `@apollion-dsi/relay` (root barrel).
  */
 export * from './useEnvironment';

package/lib/useEnvironment/index.esm.js

@@ -0,0 +1 @@
+import{a,b}from"../chunks/chunk-54QV6DFY.esm.js";import"../chunks/chunk-GZONWSRB.esm.js";export{a as EnvironmentProvider,b as useEnvironment};

package/lib/useEnvironment/useEnvironment.d.ts

@@ -2,24 +2,24 @@ import React from 'react';
 import { Environment } from 'relay-runtime';
 import { MockEnvironment } from 'relay-test-utils';
 /**
- * Estado interno do Context: contém apenas o `Environment` Relay
- * (real ou mockado em testes).
+ * Internal Context state: contains only the Relay `Environment`
+ * (real, or mocked in tests).
  */
 type StateType = {
     environment: Environment | MockEnvironment;
 };
 /**
- * Props do `EnvironmentProvider`.
+ * Props for `EnvironmentProvider`.
  */
 type EnvironmentProviderInterface = {
     children: React.ReactNode;
 } & StateType;
 /**
- * Provider que injeta o `Environment` Relay na árvore React via Context.
+ * Provider that injects the Relay `Environment` into the React tree via Context.
  *
- * Em produção, passe a propriedade `Environment` exposta por
- * `CreateRelayEnvironment`. Em testes, passe um `MockEnvironment` de
- * `relay-test-utils` para facilitar a substituição do backend.
+ * In production, pass the `Environment` property exposed by
+ * `CreateRelayEnvironment`. In tests, pass a `MockEnvironment` from
+ * `relay-test-utils` to make swapping out the backend easier.
  *
  * @example
  * ```tsx
@@ -36,7 +36,7 @@ type EnvironmentProviderInterface = {
  * }
  * ```
  *
- * @example Em testes
+ * @example In tests
  * ```tsx
  * import { createMockEnvironment } from 'relay-test-utils';
  *
@@ -50,16 +50,16 @@ type EnvironmentProviderInterface = {
  */
 declare function EnvironmentProvider({ children, environment }: EnvironmentProviderInterface): React.JSX.Element;
 /**
- * Hook para acessar o `Environment` Relay corrente.
+ * Hook to access the current Relay `Environment`.
  *
- * Deve ser usado dentro de um `EnvironmentProvider`. Lança erro
- * descritivo caso seja chamado fora dele ou se nenhum environment
- * tenha sido fornecido — falhas silenciosas aqui geralmente viram
- * "loading infinito" no Relay, então preferimos falhar cedo.
+ * Must be used inside an `EnvironmentProvider`. Throws a descriptive
+ * error if called outside of it or if no environment was
+ * provided — silent failures here usually turn into
+ * "infinite loading" in Relay, so we prefer to fail early.
  *
- * @returns Objeto com a propriedade `environment`.
- * @throws {Error} Quando usado fora de `EnvironmentProvider` ou quando
- *   o environment fornecido é `null`/`undefined`.
+ * @returns Object with the `environment` property.
+ * @throws {Error} When used outside `EnvironmentProvider` or when
+ *   the provided environment is `null`/`undefined`.
  *
  * @example
  * ```tsx