@ai-sdk/svelte 0.0.0-02dba89b-20251009204516

package/src/utils.svelte.ts

@@ -0,0 +1,66 @@
+import { getContext, hasContext, setContext, untrack } from 'svelte';
+import { SvelteMap } from 'svelte/reactivity';
+
+export function createContext<T>(name: string) {
+  const key = Symbol(name);
+  return {
+    hasContext: () => {
+      // At the time of writing there's no way to determine if we're
+      // currently initializing a component without a try-catch
+      try {
+        return hasContext(key);
+      } catch (e) {
+        if (
+          typeof e === 'object' &&
+          e !== null &&
+          'message' in e &&
+          typeof e.message === 'string' &&
+          e.message?.includes('lifecycle_outside_component')
+        ) {
+          return false;
+        }
+
+        throw e;
+      }
+    },
+    getContext: () => getContext<T>(key),
+    setContext: (value: T) => setContext(key, value),
+  };
+}
+
+export function promiseWithResolvers<T>(): {
+  promise: Promise<T>;
+  resolve: (value: T) => void;
+  reject: (reason?: unknown) => void;
+} {
+  let resolve: (value: T) => void;
+  let reject: (reason?: unknown) => void;
+  const promise = new Promise<T>((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve: resolve!, reject: reject! };
+}
+
+export class KeyedStore<T> extends SvelteMap<string, T> {
+  #itemConstructor: new () => T;
+
+  constructor(
+    itemConstructor: new () => T,
+    value?: Iterable<readonly [string, T]> | null | undefined,
+  ) {
+    super(value);
+    this.#itemConstructor = itemConstructor;
+  }
+
+  get(key: string): T {
+    const test =
+      super.get(key) ??
+      // Untrack here because this is technically a state mutation, meaning
+      // deriveds downstream would fail. Because this is idempotent (even
+      // though it's not pure), it's safe.
+      untrack(() => this.set(key, new this.#itemConstructor())).get(key)!;
+
+    return test;
+  }
+}