@mearie/svelte 0.0.0-next-20260228035926

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright 2025 Bae Junehyeon
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,73 @@
+# @mearie/svelte
+
+Svelte bindings for Mearie GraphQL client.
+
+This package provides Svelte stores, utilities, and the GraphQL client runtime
+for using Mearie in Svelte applications.
+
+## Installation
+
+```bash
+npm install -D mearie
+npm install @mearie/svelte
+```
+
+The `mearie` package provides build-time code generation, while `@mearie/svelte`
+includes the runtime client and Svelte-specific stores.
+
+## Usage
+
+First, create a client and set it up in your app:
+
+```svelte
+<!-- src/App.svelte -->
+<script lang="ts">
+import { createClient, httpExchange, cacheExchange, dedupExchange, setClient } from '@mearie/svelte';
+import { schema } from '$mearie';
+
+const client = createClient({
+  schema,
+  exchanges: [dedupExchange(), cacheExchange(), httpExchange({ url: 'https://api.example.com/graphql' })],
+});
+
+setClient(client);
+</script>
+```
+
+Then use it in your components:
+
+```svelte
+<!-- src/components/UserProfile.svelte -->
+<script lang="ts">
+import { graphql } from '$mearie';
+import { createQuery } from '@mearie/svelte';
+
+interface Props {
+  userId: string;
+}
+
+let { userId }: Props = $props();
+
+const query = createQuery(
+  graphql(`
+    query GetUser($id: ID!) {
+      user(id: $id) {
+        id
+        name
+      }
+    }
+  `),
+  () => ({ id: userId }),
+);
+</script>
+
+{#if query.loading}
+  <div>Loading...</div>
+{:else}
+  <h1>{query.data.user.name}</h1>
+{/if}
+```
+
+## Documentation
+
+Full documentation is available at <https://mearie.dev/frameworks/svelte>.

package/dist/index.svelte.cjs

@@ -0,0 +1,190 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+let _mearie_core = require("@mearie/core");
+let svelte = require("svelte");
+let _mearie_core_stream = require("@mearie/core/stream");
+
+//#region src/client-context.svelte.ts
+const CLIENT_KEY = Symbol("mearie-client");
+const setClient = (client) => {
+	(0, svelte.setContext)(CLIENT_KEY, client);
+};
+const getClient = () => {
+	const client = (0, svelte.getContext)(CLIENT_KEY);
+	if (!client) throw new Error("getClient must be used within a context that has called setClient");
+	return client;
+};
+
+//#endregion
+//#region src/create-query.svelte.ts
+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 = void 0;
+		unsubscribe = (0, _mearie_core_stream.pipe)(client.executeQuery(query, typeof variables === "function" ? variables() : void 0, options?.()), (0, _mearie_core_stream.subscribe)({ next: (result) => {
+			if (result.errors && result.errors.length > 0) {
+				error = new _mearie_core.AggregatedError(result.errors);
+				loading = false;
+			} else {
+				data = result.data;
+				loading = false;
+			}
+		} }));
+	};
+	const refetch = () => {
+		(0, svelte.untrack)(execute);
+	};
+	$effect(() => {
+		execute();
+		return () => {
+			unsubscribe?.();
+		};
+	});
+	return {
+		get data() {
+			return data;
+		},
+		get loading() {
+			return loading;
+		},
+		get error() {
+			return error;
+		},
+		refetch
+	};
+});
+
+//#endregion
+//#region src/create-subscription.svelte.ts
+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 = void 0;
+		const unsubscribe = (0, _mearie_core_stream.pipe)(client.executeSubscription(subscription, typeof variables === "function" ? variables() : void 0, options?.()), (0, _mearie_core_stream.subscribe)({ next: (result) => {
+			if (result.errors && result.errors.length > 0) {
+				const err = new _mearie_core.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;
+		}
+	};
+};
+
+//#endregion
+//#region src/create-mutation.svelte.ts
+const createMutation = (mutation) => {
+	const client = getClient();
+	let data = $state();
+	let loading = $state(false);
+	let error = $state();
+	const execute = async (variables, options) => {
+		loading = true;
+		error = void 0;
+		try {
+			const result = await (0, _mearie_core_stream.pipe)(client.executeMutation(mutation, variables, options), (0, _mearie_core_stream.take)(1), _mearie_core_stream.collect);
+			if (result.errors && result.errors.length > 0) {
+				const err = new _mearie_core.AggregatedError(result.errors);
+				error = err;
+				loading = false;
+				throw err;
+			}
+			data = result.data;
+			loading = false;
+			return result.data;
+		} catch (err) {
+			if (err instanceof _mearie_core.AggregatedError) error = err;
+			loading = false;
+			throw err;
+		}
+	};
+	return [execute, {
+		get data() {
+			return data;
+		},
+		get loading() {
+			return loading;
+		},
+		get error() {
+			return error;
+		}
+	}];
+};
+
+//#endregion
+//#region src/create-fragment.svelte.ts
+const createFragment = ((fragment, fragmentRef, options) => {
+	const client = getClient();
+	const ref = fragmentRef();
+	let data;
+	if (ref == null) data = null;
+	else {
+		const result = (0, _mearie_core_stream.pipe)(client.executeFragment(fragment, $state.snapshot(ref), options?.()), _mearie_core_stream.peek);
+		if (result.data === void 0) 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 = (0, _mearie_core_stream.pipe)(client.executeFragment(fragment, $state.snapshot(currentRef), options?.()), (0, _mearie_core_stream.subscribe)({ next: (result) => {
+			if (result.data !== void 0) state = result.data;
+		} }));
+		return () => {
+			unsubscribe();
+		};
+	});
+	return { get data() {
+		return state;
+	} };
+});
+
+//#endregion
+exports.createFragment = createFragment;
+exports.createMutation = createMutation;
+exports.createQuery = createQuery;
+exports.createSubscription = createSubscription;
+exports.getClient = getClient;
+exports.setClient = setClient;
+Object.keys(_mearie_core).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return _mearie_core[k]; }
+  });
+});

package/dist/index.svelte.d.cts

@@ -0,0 +1,109 @@
+import { AggregatedError, Artifact, Client, DataOf, FragmentOptions, FragmentRefs, MutationOptions, QueryOptions, SchemaMeta, SubscriptionOptions, VariablesOf } from "@mearie/core";
+export * from "@mearie/core";
+
+//#region src/client-context.svelte.d.ts
+declare const setClient: <TMeta extends SchemaMeta = SchemaMeta>(client: Client<TMeta>) => void;
+declare const getClient: <TMeta extends SchemaMeta = SchemaMeta>() => Client<TMeta>;
+//#endregion
+//#region src/create-query.svelte.d.ts
+type CreateQueryOptions<T extends Artifact<'query'> = Artifact<'query'>> = QueryOptions<T> & {
+  skip?: boolean;
+};
+type Query<T extends Artifact<'query'>> = {
+  data: undefined;
+  loading: true;
+  error: undefined;
+  refetch: () => void;
+} | {
+  data: DataOf<T>;
+  loading: false;
+  error: undefined;
+  refetch: () => void;
+} | {
+  data: DataOf<T> | undefined;
+  loading: false;
+  error: AggregatedError;
+  refetch: () => void;
+};
+type DefinedQuery<T extends Artifact<'query'>> = {
+  data: DataOf<T>;
+  loading: true;
+  error: undefined;
+  refetch: () => void;
+} | {
+  data: DataOf<T>;
+  loading: false;
+  error: undefined;
+  refetch: () => void;
+} | {
+  data: DataOf<T>;
+  loading: false;
+  error: AggregatedError;
+  refetch: () => void;
+};
+type CreateQueryFn = {
+  <T extends Artifact<'query'>>(query: T, variables: (() => VariablesOf<T>) | undefined, options: () => CreateQueryOptions<T> & {
+    initialData: DataOf<T>;
+  }): DefinedQuery<T>;
+  <T extends Artifact<'query'>>(query: T, ...[variables, options]: VariablesOf<T> extends Record<string, never> ? [undefined?, (() => CreateQueryOptions<T>)?] : [() => VariablesOf<T>, (() => CreateQueryOptions<T>)?]): Query<T>;
+};
+declare const createQuery: CreateQueryFn;
+//#endregion
+//#region src/create-subscription.svelte.d.ts
+type Subscription<T extends Artifact<'subscription'>> = {
+  data: undefined;
+  loading: true;
+  error: undefined;
+} | {
+  data: DataOf<T> | undefined;
+  loading: false;
+  error: undefined;
+} | {
+  data: DataOf<T> | undefined;
+  loading: false;
+  error: AggregatedError;
+};
+type CreateSubscriptionOptions<T extends Artifact<'subscription'>> = SubscriptionOptions & {
+  skip?: boolean;
+  onData?: (data: DataOf<T>) => void;
+  onError?: (error: AggregatedError) => void;
+};
+declare const createSubscription: <T extends Artifact<"subscription">>(subscription: T, ...[variables, options]: VariablesOf<T> extends Record<string, never> ? [undefined?, (() => CreateSubscriptionOptions<T>)?] : [() => VariablesOf<T>, (() => CreateSubscriptionOptions<T>)?]) => Subscription<T>;
+//#endregion
+//#region src/create-mutation.svelte.d.ts
+type MutationResult<T extends Artifact<'mutation'>> = {
+  data: undefined;
+  loading: true;
+  error: undefined;
+} | {
+  data: DataOf<T> | undefined;
+  loading: false;
+  error: undefined;
+} | {
+  data: DataOf<T> | undefined;
+  loading: false;
+  error: AggregatedError;
+};
+type CreateMutationOptions = MutationOptions;
+type Mutation<T extends Artifact<'mutation'>> = [(...[variables, options]: VariablesOf<T> extends Record<string, never> ? [undefined?, CreateMutationOptions?] : [VariablesOf<T>, CreateMutationOptions?]) => Promise<DataOf<T>>, MutationResult<T>];
+declare const createMutation: <T extends Artifact<"mutation">>(mutation: T) => Mutation<T>;
+//#endregion
+//#region src/create-fragment.svelte.d.ts
+type CreateFragmentOptions = FragmentOptions;
+type Fragment<T extends Artifact<'fragment'>> = {
+  data: DataOf<T>;
+};
+type FragmentList<T extends Artifact<'fragment'>> = {
+  data: DataOf<T>[];
+};
+type OptionalFragment<T extends Artifact<'fragment'>> = {
+  data: DataOf<T> | null;
+};
+type CreateFragmentFn = {
+  <T extends Artifact<'fragment'>>(fragment: T, fragmentRef: () => FragmentRefs<T['name']>[], options?: () => CreateFragmentOptions): FragmentList<T>;
+  <T extends Artifact<'fragment'>>(fragment: T, fragmentRef: () => FragmentRefs<T['name']>, options?: () => CreateFragmentOptions): Fragment<T>;
+  <T extends Artifact<'fragment'>>(fragment: T, fragmentRef: () => FragmentRefs<T['name']> | null | undefined, options?: () => CreateFragmentOptions): OptionalFragment<T>;
+};
+declare const createFragment: CreateFragmentFn;
+//#endregion
+export { type CreateFragmentOptions, type CreateMutationOptions, type CreateQueryOptions, type CreateSubscriptionOptions, type DefinedQuery, type Fragment, type FragmentList, type Mutation, type MutationResult, type OptionalFragment, type Query, type Subscription, createFragment, createMutation, createQuery, createSubscription, getClient, setClient };

package/dist/index.svelte.d.mts

@@ -0,0 +1,109 @@
+import { AggregatedError, Artifact, Client, DataOf, FragmentOptions, FragmentRefs, MutationOptions, QueryOptions, SchemaMeta, SubscriptionOptions, VariablesOf } from "@mearie/core";
+export * from "@mearie/core";
+
+//#region src/client-context.svelte.d.ts
+declare const setClient: <TMeta extends SchemaMeta = SchemaMeta>(client: Client<TMeta>) => void;
+declare const getClient: <TMeta extends SchemaMeta = SchemaMeta>() => Client<TMeta>;
+//#endregion
+//#region src/create-query.svelte.d.ts
+type CreateQueryOptions<T extends Artifact<'query'> = Artifact<'query'>> = QueryOptions<T> & {
+  skip?: boolean;
+};
+type Query<T extends Artifact<'query'>> = {
+  data: undefined;
+  loading: true;
+  error: undefined;
+  refetch: () => void;
+} | {
+  data: DataOf<T>;
+  loading: false;
+  error: undefined;
+  refetch: () => void;
+} | {
+  data: DataOf<T> | undefined;
+  loading: false;
+  error: AggregatedError;
+  refetch: () => void;
+};
+type DefinedQuery<T extends Artifact<'query'>> = {
+  data: DataOf<T>;
+  loading: true;
+  error: undefined;
+  refetch: () => void;
+} | {
+  data: DataOf<T>;
+  loading: false;
+  error: undefined;
+  refetch: () => void;
+} | {
+  data: DataOf<T>;
+  loading: false;
+  error: AggregatedError;
+  refetch: () => void;
+};
+type CreateQueryFn = {
+  <T extends Artifact<'query'>>(query: T, variables: (() => VariablesOf<T>) | undefined, options: () => CreateQueryOptions<T> & {
+    initialData: DataOf<T>;
+  }): DefinedQuery<T>;
+  <T extends Artifact<'query'>>(query: T, ...[variables, options]: VariablesOf<T> extends Record<string, never> ? [undefined?, (() => CreateQueryOptions<T>)?] : [() => VariablesOf<T>, (() => CreateQueryOptions<T>)?]): Query<T>;
+};
+declare const createQuery: CreateQueryFn;
+//#endregion
+//#region src/create-subscription.svelte.d.ts
+type Subscription<T extends Artifact<'subscription'>> = {
+  data: undefined;
+  loading: true;
+  error: undefined;
+} | {
+  data: DataOf<T> | undefined;
+  loading: false;
+  error: undefined;
+} | {
+  data: DataOf<T> | undefined;
+  loading: false;
+  error: AggregatedError;
+};
+type CreateSubscriptionOptions<T extends Artifact<'subscription'>> = SubscriptionOptions & {
+  skip?: boolean;
+  onData?: (data: DataOf<T>) => void;
+  onError?: (error: AggregatedError) => void;
+};
+declare const createSubscription: <T extends Artifact<"subscription">>(subscription: T, ...[variables, options]: VariablesOf<T> extends Record<string, never> ? [undefined?, (() => CreateSubscriptionOptions<T>)?] : [() => VariablesOf<T>, (() => CreateSubscriptionOptions<T>)?]) => Subscription<T>;
+//#endregion
+//#region src/create-mutation.svelte.d.ts
+type MutationResult<T extends Artifact<'mutation'>> = {
+  data: undefined;
+  loading: true;
+  error: undefined;
+} | {
+  data: DataOf<T> | undefined;
+  loading: false;
+  error: undefined;
+} | {
+  data: DataOf<T> | undefined;
+  loading: false;
+  error: AggregatedError;
+};
+type CreateMutationOptions = MutationOptions;
+type Mutation<T extends Artifact<'mutation'>> = [(...[variables, options]: VariablesOf<T> extends Record<string, never> ? [undefined?, CreateMutationOptions?] : [VariablesOf<T>, CreateMutationOptions?]) => Promise<DataOf<T>>, MutationResult<T>];
+declare const createMutation: <T extends Artifact<"mutation">>(mutation: T) => Mutation<T>;
+//#endregion
+//#region src/create-fragment.svelte.d.ts
+type CreateFragmentOptions = FragmentOptions;
+type Fragment<T extends Artifact<'fragment'>> = {
+  data: DataOf<T>;
+};
+type FragmentList<T extends Artifact<'fragment'>> = {
+  data: DataOf<T>[];
+};
+type OptionalFragment<T extends Artifact<'fragment'>> = {
+  data: DataOf<T> | null;
+};
+type CreateFragmentFn = {
+  <T extends Artifact<'fragment'>>(fragment: T, fragmentRef: () => FragmentRefs<T['name']>[], options?: () => CreateFragmentOptions): FragmentList<T>;
+  <T extends Artifact<'fragment'>>(fragment: T, fragmentRef: () => FragmentRefs<T['name']>, options?: () => CreateFragmentOptions): Fragment<T>;
+  <T extends Artifact<'fragment'>>(fragment: T, fragmentRef: () => FragmentRefs<T['name']> | null | undefined, options?: () => CreateFragmentOptions): OptionalFragment<T>;
+};
+declare const createFragment: CreateFragmentFn;
+//#endregion
+export { type CreateFragmentOptions, type CreateMutationOptions, type CreateQueryOptions, type CreateSubscriptionOptions, type DefinedQuery, type Fragment, type FragmentList, type Mutation, type MutationResult, type OptionalFragment, type Query, type Subscription, createFragment, createMutation, createQuery, createSubscription, getClient, setClient };

package/dist/index.svelte.mjs

@@ -0,0 +1,180 @@
+import { AggregatedError } from "@mearie/core";
+import { getContext, setContext, untrack } from "svelte";
+import { collect, peek, pipe, subscribe, take } from "@mearie/core/stream";
+
+export * from "@mearie/core"
+
+//#region src/client-context.svelte.ts
+const CLIENT_KEY = Symbol("mearie-client");
+const setClient = (client) => {
+	setContext(CLIENT_KEY, client);
+};
+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;
+};
+
+//#endregion
+//#region src/create-query.svelte.ts
+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 = void 0;
+		unsubscribe = pipe(client.executeQuery(query, typeof variables === "function" ? variables() : void 0, 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
+	};
+});
+
+//#endregion
+//#region src/create-subscription.svelte.ts
+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 = void 0;
+		const unsubscribe = pipe(client.executeSubscription(subscription, typeof variables === "function" ? variables() : void 0, 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;
+		}
+	};
+};
+
+//#endregion
+//#region src/create-mutation.svelte.ts
+const createMutation = (mutation) => {
+	const client = getClient();
+	let data = $state();
+	let loading = $state(false);
+	let error = $state();
+	const execute = async (variables, options) => {
+		loading = true;
+		error = void 0;
+		try {
+			const result = await pipe(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;
+		}
+	}];
+};
+
+//#endregion
+//#region src/create-fragment.svelte.ts
+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 === void 0) 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 !== void 0) state = result.data;
+		} }));
+		return () => {
+			unsubscribe();
+		};
+	});
+	return { get data() {
+		return state;
+	} };
+});
+
+//#endregion
+export { createFragment, createMutation, createQuery, createSubscription, getClient, setClient };

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

@@ -0,0 +1,74 @@
+{
+  "name": "@mearie/svelte",
+  "version": "0.0.0-next-20260228035926",
+  "description": "Type-safe, zero-overhead GraphQL client",
+  "keywords": [
+    "graphql",
+    "graphql-client",
+    "typescript",
+    "codegen",
+    "cache"
+  ],
+  "homepage": "https://github.com/devunt/mearie#readme",
+  "bugs": {
+    "url": "https://github.com/devunt/mearie/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/devunt/mearie.git",
+    "directory": "packages/svelte"
+  },
+  "funding": {
+    "type": "github",
+    "url": "https://github.com/sponsors/devunt"
+  },
+  "license": "MIT",
+  "author": "Bae Junehyeon <finn@penxle.io>",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "svelte": "./dist/svelte/index.svelte.js",
+      "import": {
+        "types": "./dist/index.svelte.d.mts",
+        "default": "./dist/index.svelte.mjs"
+      },
+      "require": {
+        "types": "./dist/index.svelte.d.cts",
+        "default": "./dist/index.svelte.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "package.json",
+    "README.md"
+  ],
+  "dependencies": {
+    "@mearie/core": "0.0.0-next-20260228035926"
+  },
+  "devDependencies": {
+    "svelte": "^5.53.3",
+    "tsdown": "^0.20.3",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "svelte": "^5.0.0"
+  },
+  "engines": {
+    "bun": ">=1.2.0",
+    "deno": ">=2.2.0",
+    "node": ">=20.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown && tsc -p tsconfig.svelte.json",
+    "typecheck": "tsc"
+  },
+  "main": "./dist/index.svelte.cjs",
+  "module": "./dist/index.svelte.mjs",
+  "types": "./dist/index.svelte.d.mts"
+}