@vladimirdev635/gql-client-react 0.0.106 → 0.0.108

package/index.d.ts

@@ -1,3 +1,3 @@
 export { type OperationLoadingState, type OperationSuccessState, type OperationFailureState, type OperationState, useOperation, } from './useOperation.jsx';
-export { type LazyOperationInitialState, type LazyOperationState, type UseLazyOperationReturnType, type LazyOperationExecuteReturnType, useLazyOperation } from './use-lazy-operation/index.js';
+export { type LazyOperationInitialState, type LazyOperationState, type UseLazyOperationReturnType, type LazyOperationExecuteReturnType, useLazyOperation, } from './use-lazy-operation/index.js';
 export { useSubscription } from './useSubscription.jsx';

package/index.js

@@ -1,3 +1,3 @@
 export { useOperation, } from './useOperation.jsx';
-export { useLazyOperation } from './use-lazy-operation/index.js';
+export { useLazyOperation, } from './use-lazy-operation/index.js';
 export { useSubscription } from './useSubscription.jsx';

package/loading-state.js

@@ -1 +1,3 @@
-export const loadingState = Object.freeze({ state: 'loading' });
+export const loadingState = Object.freeze({
+    state: 'loading',
+});

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@vladimirdev635/gql-client-react",
-    "version": "0.0.106",
+    "version": "0.0.108",
     "type": "module",
     "main": "./index.js",
     "types": "./index.d.ts",
@@ -13,9 +13,11 @@
         "url": "git+https://github.com/Voldemat/graphql-plus-plus.git"
     },
     "scripts": {
-        "lint": "eslint .",
-        "lint:fix": "eslint --fix .",
-        "lint:ci": "npm run lint",
+        "lint": "oxlint .",
+        "lint:fix": "oxlint --fix .",
+        "fmt": "oxfmt .",
+        "fmt:check": "oxfmt --check .",
+        "lint:ci": "npm run lint && npm run fmt:check",
         "test": "vitest",
         "build": "tsc && cp package.json .npmignore ./dist/"
     },
@@ -24,24 +26,24 @@
     "license": "ISC",
     "description": "",
     "devDependencies": {
-        "@eslint/compat": "^1.3.0",
         "@testing-library/jest-dom": "^6.6.3",
         "@testing-library/react": "^16.3.0",
         "@testing-library/user-event": "^14.6.1",
         "@types/node": "^24.0.1",
         "@types/object-hash": "^3.0.6",
         "@types/react": "^19.1.8",
-        "@typescript-eslint/eslint-plugin": "^8.34.0",
         "@vitejs/plugin-react": "^4.6.0",
-        "eslint": "^9.31.0",
-        "eslint-plugin-react": "^7.37.5",
         "jiti": "^2.4.2",
         "jsdom": "^26.1.0",
+        "oxfmt": "^0.64.0",
+        "oxlint": "^1.79.0",
+        "typescript": "<7.0.0",
+        "typescript-language-server": "^5.3.0",
         "vitest": "^3.2.4"
     },
     "peerDependencies": {
-        "react": "*",
         "object-hash": ">=3.0.0",
+        "react": "*",
         "zod": ">=4.0.5"
     },
     "optionalDependencies": {

package/tests/useLazyOperation.spec.js

@@ -1,4 +1,4 @@
-import { useLazyOperation } from '../use-lazy-operation/index.js';
+import { useLazyOperation, } from '../use-lazy-operation/index.js';
 import { describe, expect, it } from 'vitest';
 import { renderHook, act } from '@testing-library/react';
 import assert from 'assert';
@@ -14,7 +14,7 @@ describe('useLazyOperation', () => {
         const executor = {
             executeSync: async () => ({
                 result: { a: 1 },
-                response: new Response()
+                response: new Response(),
             }),
         };
         const { result } = renderHook(() => useLazyOperation(executor, testOperation));
@@ -34,7 +34,9 @@ describe('useLazyOperation', () => {
     it('Should return loading state after invoking, then failure state', async () => {
         const error = new Error('Network error');
         const executor = {
-            executeSync: async () => { throw error; },
+            executeSync: async () => {
+                throw error;
+            },
         };
         const { result } = renderHook(() => useLazyOperation(executor, testOperation));
         let promise;

package/tests/useOperation.spec.jsx

@@ -8,11 +8,11 @@ describe('useOperation', () => {
         const executor = {
             executeSync: async () => ({
                 result: { a: 1 },
-                response: new Response()
+                response: new Response(),
             }),
         };
         const { result } = renderHook((props) => useOperation(...props), {
-            initialProps: [executor, testOperation, {}, {}]
+            initialProps: [executor, testOperation, {}, {}],
         });
         expect(result.current.state).toBe('loading');
         act(() => { });
@@ -24,10 +24,12 @@ describe('useOperation', () => {
     it('Should return loading state and then failure state', async () => {
         const error = new Error('Network error');
         const executor = {
-            executeSync: async () => { throw error; }
+            executeSync: async () => {
+                throw error;
+            },
         };
         const { result } = renderHook((props) => useOperation(...props), {
-            initialProps: [executor, testOperation, {}, {}]
+            initialProps: [executor, testOperation, {}, {}],
         });
         expect(result.current.state).toBe('loading');
         act(() => { });

package/tests/useSubscription.spec.jsx

@@ -16,14 +16,14 @@ describe('useSubscription', () => {
                             yield { number: 2 };
                             yield { number: 3 };
                         })(),
-                        close: () => { }
+                        close: () => { },
                     },
-                    response
+                    response,
                 };
             },
         };
         const { result } = renderHook((props) => useSubscription(...props), {
-            initialProps: [executor, testSubscription, {}, {}]
+            initialProps: [executor, testSubscription, {}, {}],
         });
         expect(result.current.state).toBe('loading');
         act(() => { });
@@ -39,10 +39,12 @@ describe('useSubscription', () => {
     it('Should return loading state and then failure state', async () => {
         const error = new Error('Network error');
         const executor = {
-            executeSubscription: async () => { throw error; }
+            executeSubscription: async () => {
+                throw error;
+            },
         };
         const { result } = renderHook((props) => useSubscription(...props), {
-            initialProps: [executor, testSubscription, {}, {}]
+            initialProps: [executor, testSubscription, {}, {}],
         });
         expect(result.current.state).toBe('loading');
         act(() => { });

package/tests/utils.js

@@ -4,12 +4,12 @@ export const testOperation = {
     name: '',
     type: 'QUERY',
     variablesSchema: z.object({}),
-    resultSchema: z.object({})
+    resultSchema: z.object({}),
 };
 export const testSubscription = {
     document: '',
     name: '',
     type: 'SUBSCRIPTION',
     variablesSchema: z.object({}),
-    resultSchema: z.object({ number: z.number() })
+    resultSchema: z.object({ number: z.number() }),
 };

package/types.d.ts

@@ -1,10 +1,11 @@
 import { z } from 'zod/v4';
-export type SchemaFor<T> = z.ZodType<T>;
+export type SchemaForInput<T> = z.ZodType<unknown, T>;
+export type SchemaForOutput<T> = z.ZodType<T>;
 interface BaseOperation<V, R> {
     name: string;
     document: string;
-    variablesSchema: SchemaFor<V>;
-    resultSchema: SchemaFor<R>;
+    variablesSchema: SchemaForInput<V>;
+    resultSchema: SchemaForOutput<R>;
 }
 export interface SyncOperation<V, R> extends BaseOperation<V, R> {
     type: 'QUERY' | 'MUTATION';

package/use-lazy-operation/hook.js

@@ -1,6 +1,8 @@
-import { useCallback, useState } from 'react';
+import { useCallback, useState, } from 'react';
 import { loadingState } from '../loading-state.js';
-const lazyInitialState = Object.freeze({ state: 'initial' });
+const lazyInitialState = Object.freeze({
+    state: 'initial',
+});
 async function execute(executor, operation, variables, requestContext, setState) {
     let newState;
     try {
@@ -19,8 +21,5 @@ export function useLazyOperation(executor, operation) {
         setState(loadingState);
         return execute(executor, operation, variables, requestContext, setState);
     }, [setState, executor, operation]);
-    return [
-        executeCallback,
-        { state, reset: () => setState(lazyInitialState) }
-    ];
+    return [executeCallback, { state, reset: () => setState(lazyInitialState) }];
 }

package/use-lazy-operation/index.d.ts

@@ -1,2 +1,2 @@
-export { useLazyOperation, } from './hook.js';
-export type { LazyOperationInitialState, LazyOperationState, LazyOperationExecuteReturnType, UseLazyOperationReturnType } from './types.js';
+export { useLazyOperation } from './hook.js';
+export type { LazyOperationInitialState, LazyOperationState, LazyOperationExecuteReturnType, UseLazyOperationReturnType, } from './types.js';

package/use-lazy-operation/index.js

@@ -1 +1 @@
-export { useLazyOperation, } from './hook.js';
+export { useLazyOperation } from './hook.js';

package/useOperation.jsx

@@ -1,21 +1,26 @@
-import { useEffect, useMemo, useState } from 'react';
 import hash from 'object-hash';
+import { useEffect, useMemo, useState } from 'react';
 import { loadingState } from './loading-state.js';
 export function useOperation(executor, operation, variables, requestContext) {
     const [state, setState] = useState(loadingState);
-    const memoizedVariables = useMemo(() => variables, [hash(variables)]);
-    const memoizedRequestContext = useMemo(() => requestContext, [hash(requestContext)]);
+    const memoizedVariables = useMemo(() => variables, 
+    // oxlint-disable-next-line exhaustive-deps,use-memo
+    [hash(variables)]);
+    const memoizedRequestContext = useMemo(() => requestContext, 
+    // oxlint-disable-next-line exhaustive-deps,use-memo
+    [hash(requestContext)]);
     useEffect(() => {
-        executor.executeSync(operation, variables, requestContext)
-            .then(result => setState({ state: 'success', ...result }))
-            .catch(error => setState({ state: 'failure', error }));
+        executor
+            .executeSync(operation, memoizedVariables, memoizedRequestContext)
+            .then((result) => setState({ state: 'success', ...result }))
+            .catch((error) => setState({ state: 'failure', error }));
         return () => setState(loadingState);
     }, [
         setState,
         executor,
         operation,
         memoizedVariables,
-        memoizedRequestContext
+        memoizedRequestContext,
     ]);
     return state;
 }

package/useSubscription.jsx

@@ -3,17 +3,34 @@ import hash from 'object-hash';
 import { loadingState } from './loading-state.js';
 export function useSubscription(executor, operation, variables, requestContext) {
     const [state, setState] = useState(loadingState);
-    const memoizedVariables = useMemo(() => variables, [hash(variables)]);
-    const memoizedRequestContext = useMemo(() => requestContext, [hash(requestContext)]);
+    const memoizedVariables = useMemo(() => variables, 
+    // oxlint-disable-next-line exhaustive-deps,use-memo
+    [hash(variables)]);
+    const memoizedRequestContext = useMemo(() => requestContext, 
+    // oxlint-disable-next-line exhaustive-deps,use-memo
+    [hash(requestContext)]);
     useEffect(() => {
-        executor.executeSubscription(operation, variables, requestContext, new AbortController())
-            .then(result => setState({ state: 'success', ...result }))
-            .catch(error => setState({ state: 'failure', error }));
+        const controller = new AbortController();
+        executor
+            .executeSubscription(operation, memoizedVariables, memoizedRequestContext, controller)
+            .then((result) => {
+            if (controller.signal.aborted)
+                return;
+            setState({ state: 'success', ...result });
+        })
+            .catch((error) => {
+            if (controller.signal.aborted)
+                return;
+            setState({ state: 'failure', error });
+        });
         return () => {
-            setState(currentState => {
+            setState((currentState) => {
                 if (currentState.state === 'success') {
                     currentState.result.close();
                 }
+                else {
+                    controller.abort();
+                }
                 return loadingState;
             });
         };
@@ -22,7 +39,7 @@ export function useSubscription(executor, operation, variables, requestContext)
         executor,
         operation,
         memoizedVariables,
-        memoizedRequestContext
+        memoizedRequestContext,
     ]);
     return state;
 }