svelte-effect-runtime 1.2.3 → 1.3.0

package/dist/root-node.js

@@ -1,8 +1,63 @@
-import { t as transformEffectMarkup } from "./chunks/markup-Ccw42uCl.js";
-import { transformEffectScript } from "./internal/transform.js";
-import { effectPreprocess } from "./preprocess.js";
-import { ClientRuntime, ClientRuntimeTag, getEffectRuntimeOrThrow, provideEffectRuntime, registerHotDispose, runComponentEffect, runInlineEffect, to_effect, to_native } from "./client.js";
-import "./mod.js";
-import { svelteEffectRuntime, sveltekitEffectRuntime } from "./vite.js";
-import { effect } from "./effect.js";
-export { ClientRuntime, ClientRuntimeTag, effect, effectPreprocess, getEffectRuntimeOrThrow, provideEffectRuntime, registerHotDispose, runComponentEffect, runInlineEffect, svelteEffectRuntime, sveltekitEffectRuntime, to_effect, to_native, transformEffectMarkup, transformEffectScript };
+import { a as run_component_effect, c as to_native, o as run_inline_effect, r as get_effect_runtime_or_throw, s as to_effect, t as ClientRuntime } from "./chunks/client-DkW4e4dD.js";
+import "./chunks/v3-p8V3Drpp.js";
+import { a as RequestEvent$1, c as get_server_runtime_or_throw$1, i as Query$1, n as Form$1, o as ServerRuntime$1, r as Prerender$1, s as create_effect_transport$1, t as Command$1 } from "./chunks/server-DR-6LMdP.js";
+import { t as effect } from "./chunks/effect-CL8GJs8A.js";
+//#region v3/root-node.ts
+/**
+* Define a read-only remote function that returns an `Effect` on the client.
+*
+* @see https://ser.barekey.dev/content/remote-functions/query
+*/
+const Query = Query$1;
+/**
+* Define a write-oriented remote function that returns an `Effect` on the
+* client.
+*
+* @see https://ser.barekey.dev/content/remote-functions/command
+*/
+const Command = Command$1;
+/**
+* Define a remote form handler that maps submitted data into an Effect
+* program.
+*
+* @see https://ser.barekey.dev/content/remote-functions/form
+*/
+const Form = Form$1;
+/**
+* Define a prerenderable remote function backed by an Effect program.
+*
+* @see https://ser.barekey.dev/content/remote-functions/prerender
+*/
+const Prerender = Prerender$1;
+/**
+* Effect `Context.Tag` for the current SvelteKit `RequestEvent`.
+*
+* @see https://ser.barekey.dev/content/runtimes/server
+*/
+const RequestEvent = RequestEvent$1;
+/**
+* Server-side runtime builder used to provide long-lived Effect services to
+* remote functions.
+*
+* @see https://ser.barekey.dev/content/reference/server-runtime
+*/
+const ServerRuntime = ServerRuntime$1;
+/**
+* Build a devalue transport table from Effect schemas so remote payloads can
+* round-trip custom data across the client/server boundary.
+*
+* @see https://ser.barekey.dev/content/reference/transport
+*/
+const create_effect_transport = create_effect_transport$1;
+/**
+* Resolve the active server runtime, lazily creating a default empty runtime
+* when no explicit one has been registered.
+*
+* @internal Internal - do not use.
+* @see https://ser.barekey.dev/content/reference/server-runtime
+*/
+const get_server_runtime_or_throw = get_server_runtime_or_throw$1;
+//#endregion
+export { ClientRuntime, Command, Form, Prerender, Query, RequestEvent, ServerRuntime, create_effect_transport, effect, get_effect_runtime_or_throw, get_server_runtime_or_throw, run_component_effect, run_inline_effect, to_effect, to_native };
+
+//# sourceMappingURL=root-node.js.map

package/dist/root-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"root-node.js","names":["Server_module.Query","Server_module.Command","Server_module.Form","Server_module.Prerender","Server_module.RequestEvent","Server_module.ServerRuntime","Server_module.create_effect_transport","Server_module.get_server_runtime_or_throw"],"sources":["../../modules/svelte-effect-runtime/v3/root-node.ts"],"sourcesContent":["import * as Server_module from \"$/v3/server.ts\";\n\nexport * from \"$/v3/mod.ts\";\nexport type * from \"$/v3/server.ts\";\nexport type { EffectPluginOptions } from \"$/v3/effect.ts\";\nexport { effect } from \"$/v3/effect.ts\";\n\n/**\n * Define a read-only remote function that returns an `Effect` on the client.\n *\n * @see https://ser.barekey.dev/content/remote-functions/query\n */\nexport const Query: typeof Server_module.Query = Server_module.Query;\n/**\n * Define a write-oriented remote function that returns an `Effect` on the\n * client.\n *\n * @see https://ser.barekey.dev/content/remote-functions/command\n */\nexport const Command: typeof Server_module.Command = Server_module.Command;\n/**\n * Define a remote form handler that maps submitted data into an Effect\n * program.\n *\n * @see https://ser.barekey.dev/content/remote-functions/form\n */\nexport const Form: typeof Server_module.Form = Server_module.Form;\n/**\n * Define a prerenderable remote function backed by an Effect program.\n *\n * @see https://ser.barekey.dev/content/remote-functions/prerender\n */\nexport const Prerender: typeof Server_module.Prerender = Server_module.Prerender;\n/**\n * Effect `Context.Tag` for the current SvelteKit `RequestEvent`.\n *\n * @see https://ser.barekey.dev/content/runtimes/server\n */\nexport const RequestEvent: typeof Server_module.RequestEvent =\n  Server_module.RequestEvent;\n/**\n * Server-side runtime builder used to provide long-lived Effect services to\n * remote functions.\n *\n * @see https://ser.barekey.dev/content/reference/server-runtime\n */\nexport const ServerRuntime: typeof Server_module.ServerRuntime =\n  Server_module.ServerRuntime;\n/**\n * Build a devalue transport table from Effect schemas so remote payloads can\n * round-trip custom data across the client/server boundary.\n *\n * @see https://ser.barekey.dev/content/reference/transport\n */\nexport const create_effect_transport: typeof Server_module.create_effect_transport =\n  Server_module.create_effect_transport;\n/**\n * Resolve the active server runtime, lazily creating a default empty runtime\n * when no explicit one has been registered.\n *\n * @internal Internal - do not use.\n * @see https://ser.barekey.dev/content/reference/server-runtime\n */\nexport const get_server_runtime_or_throw:\n  typeof Server_module.get_server_runtime_or_throw =\n    Server_module.get_server_runtime_or_throw;\n"],"mappings":";;;;;;;;;;AAYA,MAAa,QAAoCA;;;;;;;AAOjD,MAAa,UAAwCC;;;;;;;AAOrD,MAAa,OAAkCC;;;;;;AAM/C,MAAa,YAA4CC;;;;;;AAMzD,MAAa,eACXC;;;;;;;AAOF,MAAa,gBACXC;;;;;;;AAOF,MAAa,0BACXC;;;;;;;;AAQF,MAAa,8BAETC"}

package/dist/server.d.ts

@@ -1,129 +1,56 @@
-import { getRequestEvent as get_native_request_event } from "$app/server";
-import * as Context from "effect/Context";
-import * as Effect from "effect/Effect";
-import * as Layer from "effect/Layer";
-import * as ManagedRuntime from "effect/ManagedRuntime";
-import * as Schema from "effect/Schema";
-import { type FormError } from "./internal/remote-shared.ts";
-type EffectSchema = Schema.Schema.Any;
-export interface Transporter<T = unknown, U = {
-    value: unknown;
-}> {
-    decode: (data: U) => T;
-    encode: (value: T) => false | U;
-}
-export type Transport = Record<string, Transporter>;
-export interface RemoteFormInput {
-    [key: string]: string | number | boolean | File | RemoteFormInput | Array<string | number | boolean | File | RemoteFormInput>;
-}
-export type RemoteQueryFunction<Input, Output> = (arg: OptionalArgument<Input>) => Promise<Output>;
-export type RemoteCommand<Input, Output> = ((arg: OptionalArgument<Input>) => Promise<Output> & {
-    updates(...updates: Array<unknown>): Promise<Output>;
-}) & {
-    readonly pending: number;
-};
-export type RemotePrerenderFunction<Input, Output> = (arg: OptionalArgument<Input>) => Promise<Output>;
-export type RemoteForm<Input extends RemoteFormInput | void, Output> = {
-    readonly action: string;
-    enhance: (...args: Array<unknown>) => {
-        readonly action: string;
-        readonly method: "POST";
-    };
-    fields: Record<string, unknown>;
-    for: (id: string | number) => RemoteForm<Input, Output>;
-    readonly method: "POST";
-    readonly pending: number;
-    preflight: (schema: unknown) => RemoteForm<Input, Output>;
-    readonly result: Output | undefined;
-    validate: (options?: {
-        includeUntouched?: boolean;
-        preflightOnly?: boolean;
-    }) => Promise<void>;
-    [attachment: symbol]: (node: HTMLFormElement) => void;
-};
-type RuntimeOperator = (self: Layer.Layer<unknown, unknown, unknown>) => Layer.Layer<unknown, unknown, unknown>;
-type RuntimeSeedLayer<Requirements> = Layer.Layer<Requirements, never, Requirements>;
-type ProvidedBy<Op> = Op extends (self: RuntimeSeedLayer<infer Requirements>) => Layer.Layer<unknown, unknown, infer Incoming> ? Exclude<Requirements, Incoming> : never;
-type ProvidedByAll<Ops extends ReadonlyArray<RuntimeOperator>> = Ops extends readonly [infer Head, ...infer Tail] ? ProvidedBy<Head> | ProvidedByAll<Extract<Tail, ReadonlyArray<RuntimeOperator>>> : never;
-type ApplyOperator<Seed, Op> = Op extends (self: Seed) => infer Out ? Out : never;
-type ApplyOperators<Seed, Ops extends ReadonlyArray<RuntimeOperator>> = Ops extends readonly [infer Head, ...infer Tail] ? ApplyOperators<ApplyOperator<Seed, Head>, Extract<Tail, ReadonlyArray<RuntimeOperator>>> : Seed;
-type FinalRuntimeLayer<Ops extends ReadonlyArray<RuntimeOperator>> = ApplyOperators<RuntimeSeedLayer<ProvidedByAll<Ops>>, Ops> extends infer Out ? Out extends Layer.Layer<unknown, unknown, infer Incoming> ? [Incoming] extends [never] ? Out : never : never : never;
-type OptionalArgument<Input> = undefined extends Input ? Input | void : Input;
-type SchemaInput<SchemaType extends EffectSchema> = Schema.Schema.Encoded<SchemaType>;
-type SchemaOutput<SchemaType extends EffectSchema> = Schema.Schema.Type<SchemaType>;
-type FieldHelpers<FormShape, SchemaType> = FormShape extends Record<string, unknown> ? {
-    [Key in keyof FormShape as Key extends string ? Key : never]: (message: string) => Effect.Effect<never, FormError<SchemaType>, never>;
-} : Record<PropertyKey, never>;
-export type Invalid<SchemaType = unknown> = {
-    form: (message: string) => Effect.Effect<never, FormError<SchemaType>, never>;
-} & FieldHelpers<SchemaType extends EffectSchema ? SchemaOutput<SchemaType> : unknown, SchemaType>;
-export type EffectQueryFunction<Input, Output, Error = never> = ((arg: OptionalArgument<Input>) => Effect.Effect<Output, import("./internal/remote-shared.ts").RemoteFailure<Error>, never>) & {
-    native: RemoteQueryFunction<Input, Output>;
-};
-export type EffectCommand<Input, Output, Error = never> = ((arg: OptionalArgument<Input>) => Effect.Effect<Output, import("./internal/remote-shared.ts").RemoteFailure<Error>, never>) & {
-    native: RemoteCommand<Input, Output>;
-    readonly pending: number;
-};
-export type EffectPrerenderFunction<Input, Output, Error = never> = ((arg: OptionalArgument<Input>) => Effect.Effect<Output, import("./internal/remote-shared.ts").RemoteFailure<Error>, never>) & {
-    native: RemotePrerenderFunction<Input, Output>;
-};
-export type EffectForm<Input extends RemoteFormInput | void, Output, Error = never> = RemoteForm<Input, Output> & {
-    native: RemoteForm<Input, Output>;
-    submit(data: OptionalArgument<Input>): Effect.Effect<Output, import("./internal/remote-shared.ts").RemoteFailure<Error>, never>;
-    for: RemoteForm<Input, Output>["for"] extends (...args: infer Args) => infer Result ? (...args: Args) => EffectForm<Input, Output, Error> : never;
-};
-export type RequestEventService = ReturnType<typeof get_native_request_event>;
-export declare const RequestEvent: Context.Tag<import("@sveltejs/kit").RequestEvent<Record<string, string>, string | null>, import("@sveltejs/kit").RequestEvent<Record<string, string>, string | null>>;
-interface ServerRuntimeSeed {
-    pipe(): Layer.Layer<never>;
-    pipe<const Ops extends readonly [RuntimeOperator, ...Array<RuntimeOperator>]>(...ops: Ops): FinalRuntimeLayer<Ops>;
-    make(): void;
-    make<const Ops extends readonly [RuntimeOperator, ...Array<RuntimeOperator>]>(...ops: Ops): void;
-}
-type ServerManagedRuntime = ManagedRuntime.ManagedRuntime<unknown, unknown>;
-export declare const ServerRuntime: ServerRuntimeSeed;
-export declare function get_server_runtime_or_throw(): ServerManagedRuntime;
-export declare function create_effect_transport<const Schemas extends Record<string, EffectSchema>>(schemas: Schemas): Transport;
-export interface EffectQueryFactory {
-    <Output, ErrorType, Requirements>(fn: () => Effect.Effect<Output, ErrorType, Requirements>): EffectQueryFunction<void, Output, ErrorType>;
-    <Input, Output, ErrorType, Requirements>(validate: "unchecked", fn: (arg: Input) => Effect.Effect<Output, ErrorType, Requirements>): EffectQueryFunction<Input, Output, ErrorType>;
-    <SchemaType extends EffectSchema, Output, ErrorType, Requirements>(validate: SchemaType, fn: (arg: SchemaOutput<SchemaType>) => Effect.Effect<Output, ErrorType, Requirements>): EffectQueryFunction<SchemaInput<SchemaType>, Output, ErrorType>;
-    batch: typeof query_batch_factory;
-}
-type RemotePrerenderInputsGenerator<Input> = (event: RequestEventService) => AsyncIterable<Input> | Iterable<Input>;
-declare function query_batch_factory(validate_or_fn: unknown, maybe_fn?: unknown): unknown;
-export declare const Query: EffectQueryFactory;
-export interface EffectCommandFactory {
-    <Output, ErrorType, Requirements>(fn: () => Effect.Effect<Output, ErrorType, Requirements>): EffectCommand<void, Output, ErrorType>;
-    <Input, Output, ErrorType, Requirements>(validate: "unchecked", fn: (arg: Input) => Effect.Effect<Output, ErrorType, Requirements>): EffectCommand<Input, Output, ErrorType>;
-    <SchemaType extends EffectSchema, Output, ErrorType, Requirements>(validate: SchemaType, fn: (arg: SchemaOutput<SchemaType>) => Effect.Effect<Output, ErrorType, Requirements>): EffectCommand<SchemaInput<SchemaType>, Output, ErrorType>;
-}
-export declare const Command: EffectCommandFactory;
-export interface EffectFormFactory {
-    <Output, ErrorType, Requirements>(fn: () => Effect.Effect<Output, ErrorType, Requirements>): EffectForm<void, Output, ErrorType>;
-    <Input extends RemoteFormInput, Output, ErrorType, Requirements>(validate: "unchecked", fn: (args: {
-        data: Input;
-        invalid: Invalid;
-    }) => Effect.Effect<Output, ErrorType | FormError, Requirements>): EffectForm<Input, Output, ErrorType>;
-    <SchemaType extends EffectSchema, Output, ErrorType, Requirements>(validate: SchemaType, fn: (args: {
-        data: SchemaOutput<SchemaType>;
-        invalid: Invalid<SchemaType>;
-    }) => Effect.Effect<Output, ErrorType | FormError<SchemaType>, Requirements>): EffectForm<SchemaInput<SchemaType> & RemoteFormInput, Output, ErrorType>;
-}
-export declare const Form: EffectFormFactory;
-export interface EffectPrerenderFactory {
-    <Output, ErrorType, Requirements>(fn: () => Effect.Effect<Output, ErrorType, Requirements>, options?: {
-        inputs?: RemotePrerenderInputsGenerator<void>;
-        dynamic?: boolean;
-    }): EffectPrerenderFunction<void, Output, ErrorType>;
-    <Input, Output, ErrorType, Requirements>(validate: "unchecked", fn: (arg: Input) => Effect.Effect<Output, ErrorType, Requirements>, options?: {
-        inputs?: RemotePrerenderInputsGenerator<Input>;
-        dynamic?: boolean;
-    }): EffectPrerenderFunction<Input, Output, ErrorType>;
-    <SchemaType extends EffectSchema, Output, ErrorType, Requirements>(validate: SchemaType, fn: (arg: SchemaOutput<SchemaType>) => Effect.Effect<Output, ErrorType, Requirements>, options?: {
-        inputs?: RemotePrerenderInputsGenerator<SchemaInput<SchemaType>>;
-        dynamic?: boolean;
-    }): EffectPrerenderFunction<SchemaInput<SchemaType>, Output, ErrorType>;
-}
-export declare const Prerender: EffectPrerenderFactory;
-export {};
+import * as Server_module from "./v3/server.js";
+export type * from "./v3/server.js";
+/**
+ * Define a read-only remote function that returns an `Effect` on the client.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/query
+ */
+export declare const Query: typeof Server_module.Query;
+/**
+ * Define a write-oriented remote function that returns an `Effect` on the
+ * client.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/command
+ */
+export declare const Command: typeof Server_module.Command;
+/**
+ * Define a remote form handler that maps submitted data into an Effect
+ * program.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/form
+ */
+export declare const Form: typeof Server_module.Form;
+/**
+ * Define a prerenderable remote function backed by an Effect program.
+ *
+ * @see https://ser.barekey.dev/content/remote-functions/prerender
+ */
+export declare const Prerender: typeof Server_module.Prerender;
+/**
+ * Effect `Context.Tag` for the current SvelteKit `RequestEvent`.
+ *
+ * @see https://ser.barekey.dev/content/runtimes/server
+ */
+export declare const RequestEvent: typeof Server_module.RequestEvent;
+/**
+ * Server-side runtime builder used to provide long-lived Effect services to
+ * remote functions.
+ *
+ * @see https://ser.barekey.dev/content/reference/server-runtime
+ */
+export declare const ServerRuntime: typeof Server_module.ServerRuntime;
+/**
+ * Build a devalue transport table from Effect schemas so remote payloads can
+ * round-trip custom data across the client/server boundary.
+ *
+ * @see https://ser.barekey.dev/content/reference/transport
+ */
+export declare const create_effect_transport: typeof Server_module.create_effect_transport;
+/**
+ * Resolve the active server runtime, lazily creating a default empty runtime
+ * when no explicit one has been registered.
+ *
+ * @internal Internal - do not use.
+ * @see https://ser.barekey.dev/content/reference/server-runtime
+ */
+export declare const get_server_runtime_or_throw: typeof Server_module.get_server_runtime_or_throw;