@mearie/svelte 0.2.1 → 0.2.3

package/dist/svelte/client-context.svelte.js

@@ -0,0 +1,12 @@
+import { getContext, setContext } from 'svelte';
+const CLIENT_KEY = Symbol('mearie-client');
+export const setClient = (client) => {
+    setContext(CLIENT_KEY, client);
+};
+export const getClient = () => {
+    const client = getContext(CLIENT_KEY);
+    if (!client) {
+        throw new Error('getClient must be used within a context that has called setClient');
+    }
+    return client;
+};

package/dist/svelte/create-fragment.svelte.js

@@ -0,0 +1,40 @@
+import { pipe, subscribe, peek } from '@mearie/core/stream';
+import { getClient } from "./client-context.svelte.js";
+export const createFragment = ((fragment, fragmentRef, options) => {
+    const client = getClient();
+    const ref = fragmentRef();
+    let data;
+    if (ref == null) {
+        data = null;
+    }
+    else {
+        const result = pipe(client.executeFragment(fragment, $state.snapshot(ref), options?.()), peek);
+        if (result.data === undefined) {
+            throw new Error('Fragment data not found');
+        }
+        data = result.data;
+    }
+    let state = $state(data);
+    $effect(() => {
+        const currentRef = fragmentRef();
+        if (currentRef == null) {
+            state = null;
+            return;
+        }
+        const unsubscribe = pipe(client.executeFragment(fragment, $state.snapshot(currentRef), options?.()), subscribe({
+            next: (result) => {
+                if (result.data !== undefined) {
+                    state = result.data;
+                }
+            },
+        }));
+        return () => {
+            unsubscribe();
+        };
+    });
+    return {
+        get data() {
+            return state;
+        },
+    };
+});

package/dist/svelte/create-mutation.svelte.js

@@ -0,0 +1,48 @@
+import { AggregatedError } from '@mearie/core';
+import { pipe, take, collect } from '@mearie/core/stream';
+import { getClient } from "./client-context.svelte.js";
+export const createMutation = (mutation) => {
+    const client = getClient();
+    let data = $state();
+    let loading = $state(false);
+    let error = $state();
+    const execute = async (variables, options) => {
+        loading = true;
+        error = undefined;
+        try {
+            const result = await pipe(
+            // @ts-expect-error - conditional signature makes this hard to type correctly
+            client.executeMutation(mutation, variables, options), take(1), collect);
+            if (result.errors && result.errors.length > 0) {
+                const err = new AggregatedError(result.errors);
+                error = err;
+                loading = false;
+                throw err;
+            }
+            data = result.data;
+            loading = false;
+            return result.data;
+        }
+        catch (err) {
+            if (err instanceof AggregatedError) {
+                error = err;
+            }
+            loading = false;
+            throw err;
+        }
+    };
+    return [
+        execute,
+        {
+            get data() {
+                return data;
+            },
+            get loading() {
+                return loading;
+            },
+            get error() {
+                return error;
+            },
+        },
+    ];
+};

package/dist/svelte/create-query.svelte.js

@@ -0,0 +1,59 @@
+import { untrack } from 'svelte';
+import { AggregatedError } from '@mearie/core';
+import { pipe, subscribe } from '@mearie/core/stream';
+import { getClient } from "./client-context.svelte.js";
+export const createQuery = ((query, variables, options) => {
+    const client = getClient();
+    const initialOpts = options?.();
+    let data = $state.raw(initialOpts?.initialData);
+    let loading = $state(!initialOpts?.skip && !initialOpts?.initialData);
+    let error = $state();
+    let unsubscribe = null;
+    let initialized = false;
+    const execute = () => {
+        unsubscribe?.();
+        if (options?.().skip) {
+            return;
+        }
+        if (!initialized && !!initialOpts?.initialData) {
+            loading = true;
+        }
+        initialized = true;
+        error = undefined;
+        unsubscribe = pipe(
+        // @ts-expect-error - conditional signature makes this hard to type correctly
+        client.executeQuery(query, typeof variables === 'function' ? variables() : undefined, options?.()), subscribe({
+            next: (result) => {
+                if (result.errors && result.errors.length > 0) {
+                    error = new AggregatedError(result.errors);
+                    loading = false;
+                }
+                else {
+                    data = result.data;
+                    loading = false;
+                }
+            },
+        }));
+    };
+    const refetch = () => {
+        untrack(execute);
+    };
+    $effect(() => {
+        execute();
+        return () => {
+            unsubscribe?.();
+        };
+    });
+    return {
+        get data() {
+            return data;
+        },
+        get loading() {
+            return loading;
+        },
+        get error() {
+            return error;
+        },
+        refetch,
+    };
+});

package/dist/svelte/create-subscription.svelte.js

@@ -0,0 +1,48 @@
+import { AggregatedError } from '@mearie/core';
+import { pipe, subscribe } from '@mearie/core/stream';
+import { getClient } from "./client-context.svelte.js";
+export const createSubscription = (subscription, ...[variables, options]) => {
+    const client = getClient();
+    let data = $state.raw();
+    let loading = $state(!options?.().skip);
+    let error = $state();
+    $effect(() => {
+        if (options?.().skip) {
+            return;
+        }
+        loading = true;
+        error = undefined;
+        const unsubscribe = pipe(
+        // @ts-expect-error - conditional signature makes this hard to type correctly
+        client.executeSubscription(subscription, typeof variables === 'function' ? variables() : undefined, options?.()), subscribe({
+            next: (result) => {
+                if (result.errors && result.errors.length > 0) {
+                    const err = new AggregatedError(result.errors);
+                    error = err;
+                    loading = false;
+                    options?.().onError?.(err);
+                }
+                else {
+                    const resultData = result.data;
+                    data = resultData;
+                    loading = false;
+                    options?.().onData?.(resultData);
+                }
+            },
+        }));
+        return () => {
+            unsubscribe();
+        };
+    });
+    return {
+        get data() {
+            return data;
+        },
+        get loading() {
+            return loading;
+        },
+        get error() {
+            return error;
+        },
+    };
+};

package/dist/svelte/index.svelte.js

@@ -0,0 +1,6 @@
+export * from '@mearie/core';
+export { setClient, getClient } from "./client-context.svelte.js";
+export { createQuery } from "./create-query.svelte.js";
+export { createSubscription } from "./create-subscription.svelte.js";
+export { createMutation, } from "./create-mutation.svelte.js";
+export { createFragment, } from "./create-fragment.svelte.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mearie/svelte",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Type-safe, zero-overhead GraphQL client",
   "keywords": [
     "graphql",
@@ -28,6 +28,7 @@
   "type": "module",
   "exports": {
     ".": {
+      "svelte": "./dist/svelte/index.svelte.js",
       "import": {
         "types": "./dist/index.svelte.d.mts",
         "default": "./dist/index.svelte.mjs"
@@ -64,7 +65,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsdown",
+    "build": "tsdown && tsc -p tsconfig.svelte.json",
     "typecheck": "tsc"
   },
   "main": "./dist/index.svelte.cjs",