@sjcx/vorma 0.0.0-pre.2 → 0.0.0-pre.4

package/dist/client/prepare.d.ts

@@ -1,47 +0,0 @@
-import { Effect, Exit, Scope } from "effect";
-import { type ClientLoaderTrigger } from "./client-loaders.ts";
-import type { ClientCore } from "./core.ts";
-import { NavigationError } from "./errors.ts";
-import type { HeadSections } from "./head.ts";
-import { type DecodedPayload } from "./payload.ts";
-import type { RouteEntry, RouteErrorState } from "./state.ts";
-import type { BuildMismatch, RequestKind } from "./types.ts";
-export type RouteReadSource = {
-    readonly kind: "request";
-    readonly url: URL;
-    readonly requestKind: RequestKind;
-} | {
-    readonly kind: "payload";
-    readonly url: URL;
-    readonly payload: DecodedPayload;
-};
-export type PreparedRoute = {
-    readonly url: URL;
-    readonly entries: ReadonlyArray<RouteEntry>;
-    readonly error: RouteErrorState | null;
-    readonly head: HeadSections;
-    readonly cssBundles: ReadonlyArray<string>;
-    /** The sequence of the read that produced this route. */
-    readonly sequence: number;
-    readonly generation: number;
-};
-export type PreparationOutcome = {
-    readonly _tag: "Prepared";
-    readonly prepared: PreparedRoute;
-} | {
-    readonly _tag: "Redirect";
-    readonly href: string;
-} | {
-    readonly _tag: "BuildSkew";
-    readonly mismatch: BuildMismatch;
-};
-export type PreparationDependencies = Pick<ClientCore, "getClientBuildId" | "getDeploymentId" | "prepareRequest" | "provideClient" | "advanceSequence" | "getState" | "activations" | "clientLoaders" | "reportBuildMismatch" | "runsInDevelopmentMode" | "publishEvent">;
-/** Prepares one destination. Known client loaders start before the read settles when `prestart` is set. */
-export declare function prepareRoute(core: PreparationDependencies, input: {
-    readonly source: RouteReadSource;
-    readonly trigger: ClientLoaderTrigger;
-    readonly historyState: unknown;
-    readonly prestart: boolean;
-    /** Called once: at the ready milestone, or with the failure when preparation ends before it. */
-    readonly reportReadinessFn: ((exit: Exit.Exit<void, NavigationError>) => void) | undefined;
-}): Effect.Effect<PreparationOutcome, NavigationError, Scope.Scope>;

package/dist/client/projections.d.ts

@@ -1,26 +0,0 @@
-import { Option } from "effect";
-import { Atom } from "effect/unstable/reactivity";
-import { type Frame, type RouteEntry, type RouteErrorState } from "./state.ts";
-import type { BuildMismatch, ClientLifecycle, NavigationState, OperationId, OperationState, RevalidationState, RouteState, RouteError, WorkState } from "./types.ts";
-export declare const lifecycleAtom: Atom.Atom<ClientLifecycle>;
-export declare const committedFrameAtom: Atom.Atom<Frame | null>;
-/** Projects server-public fields or preserves a browser-local cause according to its source. */
-export declare function projectRouteError(error: Pick<RouteErrorState, "pattern" | "source" | "error">): RouteError;
-/** The public route state of a frame. */
-export declare function projectRouteState(frame: Pick<Frame, "href" | "historyState" | "error"> & {
-    readonly entries: ReadonlyArray<Pick<RouteEntry, "pattern" | "params" | "splatValues">>;
-}): RouteState;
-export declare const routeStateAtom: Atom.Atom<Option.Option<RouteState>>;
-export declare const navigationStateAtom: Atom.Atom<NavigationState>;
-export declare const revalidationStateAtom: Atom.Atom<RevalidationState>;
-/**
- * Active queries depend on this; it changes only when a demand registers. It
- * is eager because its dependents are lazy runtime computations behind
- * wrappers, and the registry recomputes a lazy atom's lazy dependents only
- * when the atom itself is recomputed.
- */
-export declare const refreshEpochAtom: Atom.Atom<number>;
-export declare const buildMismatchAtom: Atom.Atom<Option.Option<BuildMismatch>>;
-export declare const workStateAtom: Atom.Atom<WorkState>;
-/** One operation's state while it is tracked; the observer retains the settled value afterward. */
-export declare const getOperationStateAtom: (arg: OperationId) => Atom.Atom<Option.Option<OperationState>>;

package/dist/client/queries.d.ts

@@ -1,33 +0,0 @@
-import { Option } from "effect";
-import { Atom, AsyncResult } from "effect/unstable/reactivity";
-import type { EndpointCallFailure, EndpointCallOutput, QueryEndpointCallInput } from "./contracts.ts";
-import type { EndpointFrameworkError, QueryResponse } from "./endpoints.ts";
-import type { QueryRedirected } from "./errors.ts";
-import { ClientCoordinator } from "./runtime.ts";
-export type QueryEndpointOutput<Input extends QueryEndpointCallInput> = QueryResponse<EndpointCallOutput<Input>>;
-export type QueryAtom<Input extends QueryEndpointCallInput, RuntimeError> = Atom.Atom<AsyncResult.AsyncResult<QueryEndpointOutput<Input>, EndpointCallFailure<Input, EndpointFrameworkError | QueryRedirected> | RuntimeError>>;
-/** The facts an acknowledgment carries; a read that never dispatched has no sequence. */
-export type QueryAcknowledgment = {
-    readonly id: string;
-    readonly dispatched: {
-        readonly sequence: number;
-        readonly generation: number;
-    } | undefined;
-    readonly success: boolean;
-};
-/** One computation of a query's reading atom, told apart from its successors. */
-export type QueryComputation = {
-    readonly id: string;
-    readonly token: symbol;
-};
-export type QueryOwner = {
-    /** A computation evaluated; the outstanding demand expects its read. */
-    readonly expect: (computation: QueryComputation) => void;
-    /** A computation's scope closed; without a successor the query is no longer expected. */
-    readonly release: (computation: QueryComputation) => void;
-    readonly acknowledge: (acknowledgment: QueryAcknowledgment) => void;
-};
-export declare function createQueryAtom<const Input extends QueryEndpointCallInput, R extends ClientCoordinator, RuntimeError>(input: {
-    readonly runtime: Atom.AtomRuntime<R, RuntimeError>;
-    readonly request: Input | Atom.Atom<Option.Option<Input>>;
-}): QueryAtom<Input, RuntimeError>;

package/dist/client/react/application.d.ts

@@ -1,87 +0,0 @@
-import { Exit, type Duration, type Effect, type Layer, type Schedule } from "effect";
-import type { ComponentType } from "react";
-import type { MissingGeneratedApplicationTypes } from "../../universal/generated-types.ts";
-import type { RevalidationError } from "../errors.ts";
-import type { ClientApplicationContracts } from "../index.ts";
-import type { PrepareRequestFn } from "../request.ts";
-import type { FrameworkClientServices } from "../runtime.ts";
-import type { BoundaryError, ClientBootError } from "../types.ts";
-import type { WorkIndicatorOptions } from "../work-indicator.ts";
-import type { DefaultLinkProps } from "./link.tsx";
-declare const CLIENT_APPLICATION_TYPES: unique symbol;
-type GeneratedApplicationCheck = ClientApplicationContracts extends {
-    readonly ui: unknown;
-    readonly endpoints: unknown;
-} ? unknown : MissingGeneratedApplicationTypes;
-type BaseOptions = {
-    readonly workIndicator?: WorkIndicatorOptions;
-    readonly defaultErrorBoundary: ComponentType<{
-        readonly error: BoundaryError;
-    }>;
-    readonly defaultLinkProps?: DefaultLinkProps;
-    readonly revalidateOnWindowFocus?: {
-        readonly staleTime: Duration.Input;
-        readonly skipWorkIndicator?: boolean;
-    };
-    readonly enableViewTransitions?: boolean;
-    /** Runs a failed refresh attempt again under this schedule; without one a failed refresh fails once. */
-    readonly refreshRetrySchedule?: Schedule.Schedule<unknown, RevalidationError>;
-};
-export type ClientApplicationOptions<ClientOnlyServices = never, ClientOnlyServicesError = never, ClientOnlyServicesRequirements = never, UniversalServices = never, UniversalServicesError = never, BrowserProgramRequirements = never, PrepareRequestRequirements = never> = BaseOptions & {
-    readonly clientOnlyServices?: Layer.Layer<ClientOnlyServices, ClientOnlyServicesError, ClientOnlyServicesRequirements>;
-    readonly universalServices?: Layer.Layer<UniversalServices, UniversalServicesError>;
-    readonly browserProgram?: Effect.Effect<unknown, unknown, BrowserProgramRequirements>;
-    readonly prepareRequestFn?: PrepareRequestFn<PrepareRequestRequirements>;
-};
-/** Every requirement of the client-only Layers, browser program, and request decorator must be supplied. */
-export type ClientApplicationRequirementCheck<ClientOnlyServices, ClientOnlyServicesRequirements, UniversalServices, BrowserProgramRequirements, PrepareRequestRequirements> = [
-    Exclude<ClientOnlyServicesRequirements, UniversalServices> | Exclude<BrowserProgramRequirements, FrameworkClientServices | ClientOnlyServices | UniversalServices> | Exclude<PrepareRequestRequirements, FrameworkClientServices | ClientOnlyServices | UniversalServices>
-] extends [never] ? unknown : {
-    readonly unsatisfiedClientApplicationRequirement: never;
-};
-export type ClientApplicationDefinition<ClientOnlyServices = never, ClientOnlyServicesError = never, UniversalServices = never, UniversalServicesError = never> = {
-    readonly _tag: "ClientApplication";
-    /**
-     * Starts the browser application: reads the bootstrap payload, builds the
-     * services, mounts React, and installs the navigation listeners. A boot
-     * that cannot commit renders `defaultErrorBoundary` in the root position
-     * and returns its failure; the promise never rejects.
-     */
-    boot(): Promise<Exit.Exit<void, ClientBootError>>;
-    dispose(): Promise<void>;
-    readonly [CLIENT_APPLICATION_TYPES]?: {
-        readonly clientOnlyServices: {
-            readonly services: ClientOnlyServices;
-            readonly error: ClientOnlyServicesError;
-        };
-        readonly universalServices: {
-            readonly services: UniversalServices;
-            readonly error: UniversalServicesError;
-        };
-    };
-};
-/** The service contracts the generated declarations read from the application definition. */
-export type GetClientApplicationServiceContracts<Definition> = Definition extends ClientApplicationDefinition<infer ClientOnlyServices, infer ClientOnlyServicesError, infer UniversalServices, infer UniversalServicesError> ? {
-    readonly clientOnlyServices: {
-        readonly services: ClientOnlyServices;
-        readonly error: ClientOnlyServicesError;
-    };
-    readonly universalServices: {
-        readonly services: UniversalServices;
-        readonly error: UniversalServicesError;
-    };
-} : {
-    readonly clientOnlyServices: {
-        readonly services: never;
-        readonly error: never;
-    };
-    readonly universalServices: {
-        readonly services: never;
-        readonly error: never;
-    };
-};
-declare function makeClientApplication<ClientOnlyServices = never, ClientOnlyServicesError = never, ClientOnlyServicesRequirements = never, UniversalServices = never, UniversalServicesError = never, BrowserProgramRequirements = never, PrepareRequestRequirements = never>(options: ClientApplicationOptions<ClientOnlyServices, ClientOnlyServicesError, ClientOnlyServicesRequirements, UniversalServices, UniversalServicesError, BrowserProgramRequirements, PrepareRequestRequirements> & GeneratedApplicationCheck & ClientApplicationRequirementCheck<ClientOnlyServices, ClientOnlyServicesRequirements, UniversalServices, BrowserProgramRequirements, PrepareRequestRequirements>): ClientApplicationDefinition<ClientOnlyServices, ClientOnlyServicesError, UniversalServices, UniversalServicesError>;
-export declare const ClientApplication: {
-    readonly make: typeof makeClientApplication;
-};
-export {};

package/dist/client/react/hooks.d.ts

@@ -1,36 +0,0 @@
-import { Option, type Duration } from "effect";
-import type { ClientLoaderState, ClientLoaderRoutePattern, LoaderData, LoaderRoutePattern, RouteMatch, RoutePattern, RouteTarget } from "../contracts.ts";
-import type { BuildMismatch, NavigationOptions, NavigationState, RevalidationState, RouteState, WorkState } from "../types.ts";
-import type { UiViewClientLoaderContract, ViewProps } from "./view.tsx";
-export type UseRouteSynchronizationOptions<Pattern extends RoutePattern = RoutePattern> = RouteTarget<Pattern> & {
-    readonly enabled?: boolean;
-    readonly debounceDelay?: Duration.Input;
-    readonly replace?: NavigationOptions["replace"];
-    readonly scrollToTop?: NavigationOptions["scrollToTop"];
-    readonly scrollToFragment?: NavigationOptions["scrollToFragment"];
-    readonly skipWorkIndicator?: boolean;
-};
-/** Keeps the browser URL synchronized with one typed React target. */
-export declare function useRouteSynchronization<const Pattern extends RoutePattern>(input: UseRouteSynchronizationOptions<Pattern>): void;
-export declare function useLoaderData<Pattern extends LoaderRoutePattern>(props: ViewProps<Pattern>): LoaderData<Pattern>;
-export declare function useLoaderData<Pattern extends LoaderRoutePattern, Selected>(props: ViewProps<Pattern>, selectFn: (value: LoaderData<Pattern>) => Selected): Selected;
-export declare function useLoaderData<Pattern extends LoaderRoutePattern>(pattern: Pattern): Option.Option<LoaderData<Pattern>>;
-export declare function useLoaderData<Pattern extends LoaderRoutePattern, Selected>(pattern: Pattern, selectFn: (value: Option.Option<LoaderData<Pattern>>) => Selected): Selected;
-export declare function useClientLoaderData<Pattern extends RoutePattern, Success, Error, Requirements>(props: ViewProps<Pattern, UiViewClientLoaderContract<Success, Error, Requirements>>): Success;
-export declare function useClientLoaderData<Pattern extends RoutePattern, Success, Error, Requirements, Selected>(props: ViewProps<Pattern, UiViewClientLoaderContract<Success, Error, Requirements>>, selectFn: (value: Success) => Selected): Selected;
-export declare function useClientLoaderData<Pattern extends ClientLoaderRoutePattern>(pattern: Pattern): Option.Option<ClientLoaderState<Pattern>>;
-export declare function useClientLoaderData<Pattern extends ClientLoaderRoutePattern, Selected>(pattern: Pattern, selectFn: (value: Option.Option<ClientLoaderState<Pattern>>) => Selected): Selected;
-export declare function useRouteMatch<Pattern extends RoutePattern>(props: ViewProps<Pattern>): RouteMatch<Pattern>;
-export declare function useRouteMatch<Pattern extends RoutePattern, Selected>(props: ViewProps<Pattern>, selectFn: (value: RouteMatch<Pattern>) => Selected): Selected;
-export declare function useRouteMatch<Pattern extends RoutePattern>(pattern: Pattern): Option.Option<RouteMatch<Pattern>>;
-export declare function useRouteMatch<Pattern extends RoutePattern, Selected>(pattern: Pattern, selectFn: (value: Option.Option<RouteMatch<Pattern>>) => Selected): Selected;
-export declare function useRouteState(): Option.Option<RouteState>;
-export declare function useRouteState<Selected>(selectFn: (route: Option.Option<RouteState>) => Selected): Selected;
-export declare function useNavigationState(): NavigationState;
-export declare function useNavigationState<Selected>(selectFn: (state: NavigationState) => Selected): Selected;
-export declare function useRevalidationState(): RevalidationState;
-export declare function useRevalidationState<Selected>(selectFn: (state: RevalidationState) => Selected): Selected;
-export declare function useWorkState(): WorkState;
-export declare function useWorkState<Selected>(selectFn: (work: WorkState) => Selected): Selected;
-export declare function useBuildMismatch(): Option.Option<BuildMismatch>;
-export declare function useBuildMismatch<Selected>(selectFn: (state: Option.Option<BuildMismatch>) => Selected): Selected;

package/dist/client/react/index.d.ts

@@ -1,5 +0,0 @@
-export type { ClientApplicationContracts } from "../index.ts";
-export { ClientApplication, type ClientApplicationDefinition, type ClientApplicationOptions, type GetClientApplicationServiceContracts, } from "./application.tsx";
-export { useBuildMismatch, useClientLoaderData, useLoaderData, useNavigationState, useRevalidationState, useRouteMatch, useRouteSynchronization, useRouteState, useWorkState, type UseRouteSynchronizationOptions, } from "./hooks.ts";
-export { Link, useLinkState, type DefaultLinkProps, type LinkProps, } from "./link.tsx";
-export { UiView, type GetUiViewClientLoaderContract, type UiViewClientLoaderContract, type UiViewDefinition, type ViewProps, } from "./view.tsx";