@thomasfosterau/effect-sveltekit 0.0.0 → 0.1.1

package/dist/transport.js.map

@@ -1 +1 @@
-{"version":3,"file":"transport.js","names":[],"sources":["../src/transport.ts"],"sourcesContent":["/**\n * Effect Schema ⇄ SvelteKit `transport` hook.\n *\n * SvelteKit's universal [`transport`](https://svelte.dev/docs/kit/hooks#Universal-hooks-transport)\n * hook moves custom (non-POJO) values across the server/client boundary — for\n * data returned from `load` functions and from remote functions. Each entry is\n * a {@link Transporter}: a sync `encode` (server) / `decode` (client) pair,\n * where `encode` returns `false` for values it does not handle.\n *\n * An Effect {@link Schema.Codec} is exactly such a pair. {@link transporter}\n * turns a schema into a `Transporter`, and {@link transport} assembles a whole\n * `transport` object from a record of schemas — so `Option`, `DateTime`,\n * branded types, `Schema.Class` instances, tagged errors, etc. round-trip with\n * no hand-written serialization.\n *\n * ```ts\n * // src/hooks.ts\n * import { Hooks } from \"@thomasfosterau/effect-sveltekit\";\n * import { Schema } from \"effect\";\n *\n * export const transport = Hooks.transport({\n *   Option: Schema.Option(Schema.Number),\n *   Date: Schema.Date,\n * });\n * ```\n */\n\nimport type { Transport, Transporter } from \"@sveltejs/kit\";\nimport { Schema } from \"effect\";\n\n/**\n * Builds a SvelteKit {@link Transporter} from an Effect {@link Schema.Codec}.\n *\n * The decoded `Type` is detected with `Schema.is`; matching values are encoded\n * with `Schema.encodeSync` and wrapped in a single-element tuple. The wrapper\n * guarantees the encoding is truthy — SvelteKit treats a falsy `encode` result\n * (e.g. an encoded `0`, `\"\"`, `false`, or `null`) as \"not this type\" — and is\n * unwrapped again by `decode` on the client.\n */\nexport const transporter = <T, E>(schema: Schema.Codec<T, E>): Transporter<T, readonly [E]> => {\n  const guard = Schema.is(schema);\n  const encode = Schema.encodeSync(schema);\n  const decode = Schema.decodeSync(schema);\n  return {\n    encode: (value) => (guard(value) ? ([encode(value)] as const) : false),\n    decode: ([data]) => decode(data),\n  };\n};\n\n/**\n * Assembles a SvelteKit `transport` object from a record of Effect schemas,\n * applying {@link transporter} to each. The keys are arbitrary labels (they\n * only need to be stable between server and client).\n */\nexport const transport = (schemas: Record<string, Schema.Codec<any, any>>): Transport => {\n  const result: Transport = {};\n  for (const [name, schema] of Object.entries(schemas)) {\n    result[name] = transporter(schema);\n  }\n  return result;\n};\n"],"mappings":";;;;;;;;;;;AAuCA,MAAa,eAAqB,WAA6D;CAC7F,MAAM,QAAQ,OAAO,GAAG,MAAM;CAC9B,MAAM,SAAS,OAAO,WAAW,MAAM;CACvC,MAAM,SAAS,OAAO,WAAW,MAAM;CACvC,OAAO;EACL,SAAS,UAAW,MAAM,KAAK,IAAK,CAAC,OAAO,KAAK,CAAC,IAAc;EAChE,SAAS,CAAC,UAAU,OAAO,IAAI;CACjC;AACF;;;;;;AAOA,MAAa,aAAa,YAA+D;CACvF,MAAM,SAAoB,CAAC;CAC3B,KAAK,MAAM,CAAC,MAAM,WAAW,OAAO,QAAQ,OAAO,GACjD,OAAO,QAAQ,YAAY,MAAM;CAEnC,OAAO;AACT"}
+{"version":3,"file":"transport.js","names":[],"sources":["../src/transport.ts"],"sourcesContent":["/**\n * Effect Schema ⇄ SvelteKit `transport` hook.\n *\n * SvelteKit's universal [`transport`](https://svelte.dev/docs/kit/hooks#Universal-hooks-transport)\n * hook moves custom (non-POJO) values across the server/client boundary — for\n * data returned from `load` functions and from remote functions. Each entry is\n * a {@link Transporter}: a sync `encode` (server) / `decode` (client) pair,\n * where `encode` returns `false` for values it does not handle.\n *\n * An Effect {@link Schema.Codec} is exactly such a pair. {@link transporter}\n * turns a schema into a `Transporter`, and {@link transport} assembles a whole\n * `transport` object from a record of schemas — so `Option`, `DateTime`,\n * branded types, `Schema.Class` instances, tagged errors, etc. round-trip with\n * no hand-written serialization.\n *\n * ```ts\n * // src/hooks.ts\n * import { Hooks } from \"@thomasfosterau/effect-sveltekit\";\n * import { Schema } from \"effect\";\n *\n * export const transport = Hooks.transport({\n *   Option: Schema.Option(Schema.Number),\n *   Date: Schema.Date,\n * });\n * ```\n */\n\nimport type { Transport, Transporter } from \"@sveltejs/kit\";\nimport { Schema } from \"effect\";\n\n/**\n * Builds a SvelteKit {@link Transporter} from an Effect {@link Schema.Codec}.\n *\n * The decoded `Type` is detected with `Schema.is`; matching values are encoded\n * with `Schema.encodeSync` and wrapped in a single-element tuple. The wrapper\n * guarantees the encoding is truthy — SvelteKit treats a falsy `encode` result\n * (e.g. an encoded `0`, `\"\"`, `false`, or `null`) as \"not this type\" — and is\n * unwrapped again by `decode` on the client.\n */\nexport const transporter = <T, E>(schema: Schema.Codec<T, E>): Transporter<T, readonly [E]> => {\n  const guard = Schema.is(schema);\n  const encode = Schema.encodeSync(schema);\n  const decode = Schema.decodeSync(schema);\n  return {\n    encode: (value) => (guard(value) ? ([encode(value)] as const) : false),\n    decode: ([data]) => decode(data),\n  };\n};\n\n/**\n * Builds a deliberately-lossy {@link Transporter} for a non-POJO wrapper whose\n * contents should *not* round-trip — the value is detected on the server and\n * reconstructed fresh on the client.\n *\n * Unlike {@link transporter} (which needs a round-tripping {@link Schema.Codec}),\n * this is for values that have no meaningful serialization but still need a\n * `transport` entry so SvelteKit doesn't reject them: `encode` returns a truthy\n * marker for matching values, and `decode` ignores it and produces a fresh value\n * from {@link MarkerTransporterOptions.make}.\n *\n * ```ts\n * // A non-serializable handle reconstructed as a fresh, empty instance:\n * export const transport = Hooks.transport({\n *   Live: Hooks.markerTransporter({\n *     guard: (v): v is LiveHandle => v instanceof LiveHandle,\n *     make: () => LiveHandle.empty(),\n *   }),\n * });\n * ```\n */\nexport const markerTransporter = <T>(\n  options: MarkerTransporterOptions<T>,\n): Transporter<T, unknown> => {\n  const marker = options.marker ?? 1;\n  return {\n    encode: (value) => (options.guard(value) ? marker : false),\n    decode: () => options.make(),\n  };\n};\n\n/** Options for {@link markerTransporter}. */\nexport interface MarkerTransporterOptions<T> {\n  /** Detect, on the server, values this transporter handles. */\n  readonly guard: (value: unknown) => value is T;\n  /** Produce a fresh value on the client (the payload is discarded). */\n  readonly make: () => T;\n  /**\n   * The truthy marker `encode` emits (SvelteKit treats a falsy `encode` result\n   * as \"not this type\"). Defaults to `1`.\n   */\n  readonly marker?: unknown;\n}\n\n/** An entry accepted by {@link transport}: an Effect schema or a ready Transporter. */\nexport type TransportEntry = Schema.Codec<any, any> | Transporter<any, any>;\n\n/**\n * Assembles a SvelteKit `transport` object from a record of entries. Each entry\n * is either an Effect {@link Schema.Codec} (wrapped with {@link transporter}) or\n * a ready {@link Transporter} (e.g. from {@link markerTransporter}), so\n * round-tripping and marker-style values can be mixed. The keys are arbitrary\n * labels (they only need to be stable between server and client).\n */\nexport const transport = (entries: Record<string, TransportEntry>): Transport => {\n  const result: Transport = {};\n  for (const [name, entry] of Object.entries(entries)) {\n    result[name] = Schema.isSchema(entry)\n      ? transporter(entry as Schema.Codec<any, any>)\n      : (entry as Transporter<any, any>);\n  }\n  return result;\n};\n"],"mappings":";;;;;;;;;;;AAuCA,MAAa,eAAqB,WAA6D;CAC7F,MAAM,QAAQ,OAAO,GAAG,MAAM;CAC9B,MAAM,SAAS,OAAO,WAAW,MAAM;CACvC,MAAM,SAAS,OAAO,WAAW,MAAM;CACvC,OAAO;EACL,SAAS,UAAW,MAAM,KAAK,IAAK,CAAC,OAAO,KAAK,CAAC,IAAc;EAChE,SAAS,CAAC,UAAU,OAAO,IAAI;CACjC;AACF;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAa,qBACX,YAC4B;CAC5B,MAAM,SAAS,QAAQ,UAAU;CACjC,OAAO;EACL,SAAS,UAAW,QAAQ,MAAM,KAAK,IAAI,SAAS;EACpD,cAAc,QAAQ,KAAK;CAC7B;AACF;;;;;;;;AAyBA,MAAa,aAAa,YAAuD;CAC/E,MAAM,SAAoB,CAAC;CAC3B,KAAK,MAAM,CAAC,MAAM,UAAU,OAAO,QAAQ,OAAO,GAChD,OAAO,QAAQ,OAAO,SAAS,KAAK,IAChC,YAAY,KAA+B,IAC1C;CAEP,OAAO;AACT"}

package/dist/universal.d.ts

@@ -1,3 +1,4 @@
+import { SvelteRouteParams } from "./internal/route-params.js";
 import { UniversalRuntime, makeUniversalRuntime } from "./app-runtime.js";
 import { Effect } from "effect";
 import * as HttpClient from "effect/unstable/http/HttpClient";
@@ -29,7 +30,7 @@ import { Load } from "@sveltejs/kit";
  * );
  * ```
  */
-declare function load<Params extends Record<string, string> = any, InputData extends Record<string, unknown> | null = any, ParentData extends Record<string, unknown> = any, OutputData extends Record<string, unknown> | void = any, RouteId extends string | null = any>(fn: (event: Parameters<Load<Params, InputData, ParentData, OutputData, RouteId>>[0]) => Effect.Effect<OutputData, unknown, HttpClient.HttpClient>): Load<Params, InputData, ParentData, OutputData, RouteId>;
+declare function load<Params extends SvelteRouteParams = SvelteRouteParams, InputData extends Record<string, unknown> | null = any, ParentData extends Record<string, unknown> = any, OutputData extends Record<string, unknown> | void = any, RouteId extends string | null = any>(fn: (event: Parameters<Load<Params, InputData, ParentData, OutputData, RouteId>>[0]) => Effect.Effect<OutputData, unknown, HttpClient.HttpClient>): Load<Params, InputData, ParentData, OutputData, RouteId>;
 //#endregion
 export { load };
 //# sourceMappingURL=universal.d.ts.map

package/dist/universal.js.map

@@ -1 +1 @@
-{"version":3,"file":"universal.js","names":["runtime"],"sources":["../src/universal.ts"],"sourcesContent":["import type { Load } from \"@sveltejs/kit\";\nimport { Effect } from \"effect\";\nimport type * as HttpClient from \"effect/unstable/http/HttpClient\";\nimport { defaultUniversalRuntime as runtime } from \"./internal/default-runtime.js\";\n\n/**\n * Wraps an Effect-based function to work as a SvelteKit universal load function.\n *\n * The effect has access to `HttpClient` on both the server and the client:\n * it is backed by the load event's `fetch`, so relative URLs and SvelteKit's\n * fetch behaviours (deduplication, cookies forwarding) work as expected.\n *\n * To give effects access to your own application services, create an\n * app-wide runtime with `makeUniversalRuntime` and use its `load` instead.\n *\n * @example\n * ```ts\n * import { load as effectLoad } from '@thomasfosterau/effect-sveltekit';\n * import * as HttpClient from 'effect/unstable/http/HttpClient';\n * import { Effect } from 'effect';\n *\n * export const load = effectLoad((event) =>\n *   Effect.gen(function* () {\n *     const client = yield* HttpClient.HttpClient;\n *     const response = yield* client.get(`/api/items/${event.params.id}`);\n *     return { item: yield* response.json };\n *   })\n * );\n * ```\n */\nexport function load<\n  Params extends Record<string, string> = any,\n  InputData extends Record<string, unknown> | null = any,\n  ParentData extends Record<string, unknown> = any,\n  OutputData extends Record<string, unknown> | void = any,\n  RouteId extends string | null = any,\n>(\n  fn: (\n    event: Parameters<Load<Params, InputData, ParentData, OutputData, RouteId>>[0],\n  ) => Effect.Effect<OutputData, unknown, HttpClient.HttpClient>,\n): Load<Params, InputData, ParentData, OutputData, RouteId> {\n  return runtime().load(fn);\n}\n\n/**\n * App-wide runtime: define your application's (universal) Effect services\n * once and share them across every `load` invocation.\n */\nexport { makeUniversalRuntime, type UniversalRuntime } from \"./app-runtime.js\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA8BA,SAAgB,KAOd,IAG0D;CAC1D,OAAOA,wBAAQ,EAAE,KAAK,EAAE;AAC1B"}
+{"version":3,"file":"universal.js","names":["runtime"],"sources":["../src/universal.ts"],"sourcesContent":["import type { Load } from \"@sveltejs/kit\";\nimport { Effect } from \"effect\";\nimport type * as HttpClient from \"effect/unstable/http/HttpClient\";\nimport type { SvelteRouteParams } from \"./internal/route-params.js\";\nimport { defaultUniversalRuntime as runtime } from \"./internal/default-runtime.js\";\n\n/**\n * Wraps an Effect-based function to work as a SvelteKit universal load function.\n *\n * The effect has access to `HttpClient` on both the server and the client:\n * it is backed by the load event's `fetch`, so relative URLs and SvelteKit's\n * fetch behaviours (deduplication, cookies forwarding) work as expected.\n *\n * To give effects access to your own application services, create an\n * app-wide runtime with `makeUniversalRuntime` and use its `load` instead.\n *\n * @example\n * ```ts\n * import { load as effectLoad } from '@thomasfosterau/effect-sveltekit';\n * import * as HttpClient from 'effect/unstable/http/HttpClient';\n * import { Effect } from 'effect';\n *\n * export const load = effectLoad((event) =>\n *   Effect.gen(function* () {\n *     const client = yield* HttpClient.HttpClient;\n *     const response = yield* client.get(`/api/items/${event.params.id}`);\n *     return { item: yield* response.json };\n *   })\n * );\n * ```\n */\nexport function load<\n  Params extends SvelteRouteParams = SvelteRouteParams,\n  InputData extends Record<string, unknown> | null = any,\n  ParentData extends Record<string, unknown> = any,\n  OutputData extends Record<string, unknown> | void = any,\n  RouteId extends string | null = any,\n>(\n  fn: (\n    event: Parameters<Load<Params, InputData, ParentData, OutputData, RouteId>>[0],\n  ) => Effect.Effect<OutputData, unknown, HttpClient.HttpClient>,\n): Load<Params, InputData, ParentData, OutputData, RouteId> {\n  return runtime().load(fn);\n}\n\n/**\n * App-wide runtime: define your application's (universal) Effect services\n * once and share them across every `load` invocation.\n */\nexport { makeUniversalRuntime, type UniversalRuntime } from \"./app-runtime.js\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+BA,SAAgB,KAOd,IAG0D;CAC1D,OAAOA,wBAAQ,EAAE,KAAK,EAAE;AAC1B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thomasfosterau/effect-sveltekit",
-  "version": "0.0.0",
+  "version": "0.1.1",
   "description": "Effect integration for SvelteKit: load/action/endpoint wrappers, remote functions, an effectKit() Vite plugin, and an Effect HTTP deployment adapter",
   "keywords": [
     "effect",
@@ -70,7 +70,7 @@
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",
     "magic-string": "^0.30.0",
-    "@thomasfosterau/effect-svelte": "^0.0.0"
+    "@thomasfosterau/effect-svelte": "^0.1.0"
   },
   "peerDependencies": {
     "@effect/platform-node": "^4.0.0-beta.75",