@go-go-scope/adapter-sveltekit 2.5.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 thelinuxlich (Alisson Cavalcante Agiani)
+
+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/dist/index.d.mts

@@ -0,0 +1,114 @@
+import { RequestEvent, Handle, ServerLoadEvent } from '@sveltejs/kit';
+import { Scope } from 'go-go-scope';
+
+/**
+ * SvelteKit adapter for go-go-scope
+ *
+ * Provides structured concurrency for SvelteKit server hooks,
+ * API routes, and form actions with automatic cleanup.
+ *
+ * @example
+ * ```typescript
+ * // src/hooks.server.ts
+ * import { createScopeHandle } from '@go-go-scope/adapter-sveltekit'
+ *
+ * export const handle = createScopeHandle({
+ *   timeout: 30000,
+ *   services: { db: createDatabase() }
+ * })
+ * ```
+ */
+
+/**
+ * SvelteKit context with scope
+ */
+interface SvelteKitContext<T extends Record<string, unknown> = Record<string, never>> {
+    /** The scope for this request */
+    scope: Scope<T>;
+    /** Request signal for cancellation */
+    signal: AbortSignal;
+}
+/**
+ * Options for scope configuration
+ */
+interface SvelteKitScopeOptions<T extends Record<string, unknown> = Record<string, never>> {
+    /** Scope timeout in milliseconds */
+    timeout?: number;
+    /** Initial services to provide */
+    services?: T;
+    /** Error handler */
+    onError?: (error: unknown, event: RequestEvent) => Response | Promise<Response>;
+}
+/**
+ * Create a SvelteKit handle with scope integration
+ *
+ * @example
+ * ```typescript
+ * // src/hooks.server.ts
+ * import { createScopeHandle } from '@go-go-scope/adapter-sveltekit'
+ * import { sequence } from '@sveltejs/kit/hooks'
+ *
+ * export const handle = sequence(
+ *   createScopeHandle({ timeout: 30000 }),
+ *   async ({ event, resolve }) => resolve(event)
+ * )
+ * ```
+ */
+declare function createScopeHandle<T extends Record<string, unknown>>(options?: SvelteKitScopeOptions<T>): Handle;
+/**
+ * Wrap a server load function with a scope
+ *
+ * @example
+ * ```typescript
+ * // src/routes/+page.server.ts
+ * import { withScopeLoad } from '@go-go-scope/adapter-sveltekit'
+ *
+ * export const load = withScopeLoad(async (event) => {
+ *   const { scope } = event.locals as { scope: Scope }
+ *   const [err, data] = await scope.task(() => fetchData())
+ *   if (err) throw error(500, err.message)
+ *   return { data }
+ * })
+ * ```
+ */
+declare function withScopeLoad<T extends Record<string, unknown>, R extends Record<string, unknown>>(loader: (event: ServerLoadEvent & {
+    scope: Scope<T>;
+}) => Promise<R> | R, options?: Omit<SvelteKitScopeOptions<T>, "services">): (event: ServerLoadEvent) => Promise<R>;
+/**
+ * Wrap a form action with a scope
+ *
+ * @example
+ * ```typescript
+ * // src/routes/+page.server.ts
+ * import { withScopeAction } from '@go-go-scope/adapter-sveltekit'
+ * import { fail } from '@sveltejs/kit'
+ *
+ * export const actions = {
+ *   create: withScopeAction(async (event) => {
+ *     const { scope } = event.locals as { scope: Scope }
+ *     const data = await event.request.formData()
+ *
+ *     const [err, result] = await scope.task(() => createItem(data))
+ *     if (err) return fail(400, { error: err.message })
+ *     return { success: true, result }
+ *   })
+ * }
+ * ```
+ */
+declare function withScopeAction<T extends Record<string, unknown>, R extends Record<string, unknown>>(action: (event: RequestEvent & {
+    scope: Scope<T>;
+}) => Promise<R> | R, options?: Omit<SvelteKitScopeOptions<T>, "services">): (event: RequestEvent) => Promise<R>;
+/**
+ * Type augmentation for SvelteKit locals
+ */
+declare global {
+    namespace App {
+        interface Locals {
+            scope?: Scope;
+            signal?: AbortSignal;
+        }
+    }
+}
+
+export { createScopeHandle, withScopeAction, withScopeLoad };
+export type { SvelteKitContext, SvelteKitScopeOptions };

package/dist/index.mjs

@@ -0,0 +1,124 @@
+import { scope } from 'go-go-scope';
+
+var __knownSymbol = (name, symbol) => (symbol = Symbol[name]) ? symbol : Symbol.for("Symbol." + name);
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __using = (stack, value, async) => {
+  if (value != null) {
+    if (typeof value !== "object" && typeof value !== "function") __typeError("Object expected");
+    var dispose, inner;
+    dispose = value[__knownSymbol("asyncDispose")];
+    if (dispose === void 0) {
+      dispose = value[__knownSymbol("dispose")];
+      inner = dispose;
+    }
+    if (typeof dispose !== "function") __typeError("Object not disposable");
+    if (inner) dispose = function() {
+      try {
+        inner.call(this);
+      } catch (e) {
+        return Promise.reject(e);
+      }
+    };
+    stack.push([async, dispose, value]);
+  } else {
+    stack.push([async]);
+  }
+  return value;
+};
+var __callDispose = (stack, error, hasError) => {
+  var E = typeof SuppressedError === "function" ? SuppressedError : function(e, s, m, _) {
+    return _ = Error(m), _.name = "SuppressedError", _.error = e, _.suppressed = s, _;
+  };
+  var fail = (e) => error = hasError ? new E(e, error, "An error was suppressed during disposal") : (hasError = true, e);
+  var next = (it) => {
+    while (it = stack.pop()) {
+      try {
+        var result = it[1] && it[1].call(it[2]);
+        if (it[0]) return Promise.resolve(result).then(next, (e) => (fail(e), next()));
+      } catch (e) {
+        fail(e);
+      }
+    }
+    if (hasError) throw error;
+  };
+  return next();
+};
+function createScopeHandle(options = {}) {
+  return async ({ event, resolve }) => {
+    var _stack = [];
+    try {
+      const abortController = new AbortController();
+      const s = __using(_stack, scope({
+        timeout: options.timeout,
+        signal: abortController.signal,
+        name: `sveltekit-${event.request.method}-${event.url.pathname}`
+      }), true);
+      if (options.services) {
+        for (const [key, value] of Object.entries(options.services)) {
+          s.provide(key, value);
+        }
+      }
+      event.locals.scope = s;
+      event.locals.signal = abortController.signal;
+      try {
+        return await resolve(event);
+      } catch (error) {
+        if (options.onError) {
+          return await options.onError(error, event);
+        }
+        throw error;
+      }
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      var _promise = __callDispose(_stack, _error, _hasError);
+      _promise && await _promise;
+    }
+  };
+}
+function withScopeLoad(loader, options = {}) {
+  return async (event) => {
+    var _stack = [];
+    try {
+      const existingScope = event.locals.scope;
+      if (existingScope) {
+        return await loader({ ...event, scope: existingScope });
+      }
+      const s = __using(_stack, scope({
+        timeout: options.timeout,
+        name: `sveltekit-load-${event.url.pathname}`
+      }), true);
+      return await loader({ ...event, scope: s });
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      var _promise = __callDispose(_stack, _error, _hasError);
+      _promise && await _promise;
+    }
+  };
+}
+function withScopeAction(action, options = {}) {
+  return async (event) => {
+    var _stack = [];
+    try {
+      const existingScope = event.locals.scope;
+      if (existingScope) {
+        return await action({ ...event, scope: existingScope });
+      }
+      const s = __using(_stack, scope({
+        timeout: options.timeout,
+        name: `sveltekit-action-${event.url.pathname}`
+      }), true);
+      return await action({ ...event, scope: s });
+    } catch (_) {
+      var _error = _, _hasError = true;
+    } finally {
+      var _promise = __callDispose(_stack, _error, _hasError);
+      _promise && await _promise;
+    }
+  };
+}
+
+export { createScopeHandle, withScopeAction, withScopeLoad };

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@go-go-scope/adapter-sveltekit",
+  "version": "2.5.0",
+  "description": "SvelteKit adapter for go-go-scope",
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "structured-concurrency",
+    "sveltekit",
+    "svelte",
+    "server-hooks",
+    "typescript"
+  ],
+  "author": "Your Name",
+  "license": "MIT",
+  "peerDependencies": {
+    "go-go-scope": "^2.4.0",
+    "@sveltejs/kit": "^2.0.0"
+  },
+  "devDependencies": {
+    "@sveltejs/kit": "^2.0.0",
+    "@types/node": "^22.13.15",
+    "pkgroll": "^2.6.1",
+    "svelte": "^5.0.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.1",
+    "go-go-scope": "2.5.0"
+  },
+  "scripts": {
+    "build": "pkgroll",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check --fix src",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "clean": "rm -rf dist"
+  }
+}