@mearie/svelte 0.2.2 → 0.2.4

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.2",
+  "version": "0.2.4",
   "description": "Type-safe, zero-overhead GraphQL client",
   "keywords": [
     "graphql",
@@ -28,10 +28,7 @@
   "type": "module",
   "exports": {
     ".": {
-      "svelte": {
-        "types": "./src/index.svelte.ts",
-        "default": "./src/index.svelte.ts"
-      },
+      "svelte": "./dist/svelte/index.svelte.js",
       "import": {
         "types": "./dist/index.svelte.d.mts",
         "default": "./dist/index.svelte.mjs"
@@ -45,12 +42,11 @@
   },
   "files": [
     "dist",
-    "src",
     "package.json",
     "README.md"
   ],
   "dependencies": {
-    "@mearie/core": "0.2.1"
+    "@mearie/core": "0.2.2"
   },
   "devDependencies": {
     "svelte": "^5.53.3",
@@ -69,7 +65,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsdown",
+    "build": "tsdown && tsc -p tsconfig.svelte.json",
     "typecheck": "tsc"
   },
   "main": "./dist/index.svelte.cjs",

package/src/client-context.svelte.ts

@@ -1,18 +0,0 @@
-import { getContext, setContext } from 'svelte';
-import type { Client, SchemaMeta } from '@mearie/core';
-
-const CLIENT_KEY = Symbol('mearie-client');
-
-export const setClient = <TMeta extends SchemaMeta = SchemaMeta>(client: Client<TMeta>): void => {
-  setContext(CLIENT_KEY, client as Client<SchemaMeta>);
-};
-
-export const getClient = <TMeta extends SchemaMeta = SchemaMeta>(): Client<TMeta> => {
-  const client = getContext<Client<SchemaMeta>>(CLIENT_KEY);
-
-  if (!client) {
-    throw new Error('getClient must be used within a context that has called setClient');
-  }
-
-  return client as Client<TMeta>;
-};

package/src/create-fragment.svelte.ts

@@ -1,87 +0,0 @@
-import type { Artifact, DataOf, FragmentRefs, OperationResult, FragmentOptions } from '@mearie/core';
-import { pipe, subscribe, peek } from '@mearie/core/stream';
-import { getClient } from './client-context.svelte.ts';
-
-export type CreateFragmentOptions = FragmentOptions;
-
-export type Fragment<T extends Artifact<'fragment'>> = {
-  data: DataOf<T>;
-};
-
-export type FragmentList<T extends Artifact<'fragment'>> = {
-  data: DataOf<T>[];
-};
-
-export 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>;
-};
-
-export const createFragment: CreateFragmentFn = (<T extends Artifact<'fragment'>>(
-  fragment: T,
-  fragmentRef: () => FragmentRefs<T['name']> | FragmentRefs<T['name']>[] | null | undefined,
-  options?: () => CreateFragmentOptions,
-) => {
-  const client = getClient();
-
-  const ref = fragmentRef();
-
-  let data: unknown;
-  if (ref == null) {
-    data = null;
-  } else {
-    const result = pipe(client.executeFragment(fragment, $state.snapshot(ref) as typeof 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) as typeof currentRef, options?.()),
-      subscribe({
-        next: (result: OperationResult) => {
-          if (result.data !== undefined) {
-            state = result.data;
-          }
-        },
-      }),
-    );
-
-    return () => {
-      unsubscribe();
-    };
-  });
-
-  return {
-    get data() {
-      return state;
-    },
-  };
-}) as unknown as CreateFragmentFn;

package/src/create-mutation.svelte.ts

@@ -1,91 +0,0 @@
-import type { VariablesOf, DataOf, Artifact, MutationOptions } from '@mearie/core';
-import { AggregatedError } from '@mearie/core';
-import { pipe, take, collect } from '@mearie/core/stream';
-import { getClient } from './client-context.svelte.ts';
-
-export 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;
-    };
-
-export type CreateMutationOptions = MutationOptions;
-
-export type Mutation<T extends Artifact<'mutation'>> = [
-  (
-    ...[variables, options]: VariablesOf<T> extends Record<string, never>
-      ? [undefined?, CreateMutationOptions?]
-      : [VariablesOf<T>, CreateMutationOptions?]
-  ) => Promise<DataOf<T>>,
-  MutationResult<T>,
-];
-
-export const createMutation = <T extends Artifact<'mutation'>>(mutation: T): Mutation<T> => {
-  const client = getClient();
-
-  let data = $state<DataOf<T> | undefined>();
-  let loading = $state<boolean>(false);
-  let error = $state<AggregatedError | undefined>();
-
-  const execute = async (variables?: VariablesOf<T>, options?: CreateMutationOptions): Promise<DataOf<T>> => {
-    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 as DataOf<T>;
-      loading = false;
-
-      return result.data as DataOf<T>;
-    } 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;
-      },
-    },
-  ] as Mutation<T>;
-};

package/src/create-query.svelte.ts

@@ -1,135 +0,0 @@
-import { untrack } from 'svelte';
-import type { Artifact, VariablesOf, DataOf, QueryOptions } from '@mearie/core';
-import { AggregatedError } from '@mearie/core';
-import { pipe, subscribe } from '@mearie/core/stream';
-import { getClient } from './client-context.svelte.ts';
-
-export type CreateQueryOptions<T extends Artifact<'query'> = Artifact<'query'>> = QueryOptions<T> & {
-  skip?: boolean;
-};
-
-export 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;
-    };
-
-export 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>;
-};
-
-export const createQuery: CreateQueryFn = (<T extends Artifact<'query'>>(
-  query: T,
-  variables?: () => VariablesOf<T>,
-  options?: () => CreateQueryOptions<T>,
-): Query<T> => {
-  const client = getClient();
-
-  const initialOpts = options?.();
-  let data = $state.raw<DataOf<T> | undefined>(initialOpts?.initialData);
-  let loading = $state<boolean>(!initialOpts?.skip && !initialOpts?.initialData);
-  let error = $state<AggregatedError | undefined>();
-
-  let unsubscribe: (() => void) | null = 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 as DataOf<T>;
-            loading = false;
-          }
-        },
-      }),
-    );
-  };
-
-  const refetch = () => {
-    untrack(execute);
-  };
-
-  $effect(() => {
-    execute();
-
-    return () => {
-      unsubscribe?.();
-    };
-  });
-
-  return {
-    get data() {
-      return data;
-    },
-    get loading() {
-      return loading;
-    },
-    get error() {
-      return error;
-    },
-    refetch,
-  } as Query<T>;
-}) as unknown as CreateQueryFn;

package/src/create-subscription.svelte.ts

@@ -1,89 +0,0 @@
-import type { VariablesOf, DataOf, Artifact, SubscriptionOptions } from '@mearie/core';
-import { AggregatedError } from '@mearie/core';
-import { pipe, subscribe } from '@mearie/core/stream';
-import { getClient } from './client-context.svelte.ts';
-
-export 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;
-    };
-
-export type CreateSubscriptionOptions<T extends Artifact<'subscription'>> = SubscriptionOptions & {
-  skip?: boolean;
-  onData?: (data: DataOf<T>) => void;
-  onError?: (error: AggregatedError) => void;
-};
-
-export 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> => {
-  const client = getClient();
-
-  let data = $state.raw<DataOf<T> | undefined>();
-  let loading = $state<boolean>(!options?.().skip);
-  let error = $state<AggregatedError | undefined>();
-
-  $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 as DataOf<T>;
-
-            data = resultData;
-            loading = false;
-
-            options?.().onData?.(resultData);
-          }
-        },
-      }),
-    );
-
-    return () => {
-      unsubscribe();
-    };
-  });
-
-  return {
-    get data() {
-      return data;
-    },
-    get loading() {
-      return loading;
-    },
-    get error() {
-      return error;
-    },
-  } as Subscription<T>;
-};

package/src/index.svelte.ts

@@ -1,17 +0,0 @@
-export * from '@mearie/core';
-export { setClient, getClient } from './client-context.svelte.ts';
-export { createQuery, type Query, type DefinedQuery, type CreateQueryOptions } from './create-query.svelte.ts';
-export { createSubscription, type Subscription, type CreateSubscriptionOptions } from './create-subscription.svelte.ts';
-export {
-  createMutation,
-  type Mutation,
-  type MutationResult,
-  type CreateMutationOptions,
-} from './create-mutation.svelte.ts';
-export {
-  createFragment,
-  type Fragment,
-  type FragmentList,
-  type OptionalFragment,
-  type CreateFragmentOptions,
-} from './create-fragment.svelte.ts';