@rikalabs/effect-react 0.0.1

package/dist/index.js

@@ -0,0 +1,207 @@
+import {
+  fetchQuery,
+  invalidate,
+  invalidateQuery,
+  prefetch,
+  prefetchQuery,
+  useInfiniteQuery,
+  useQuery,
+  useSuspenseQuery
+} from "./chunk-H7MOLKTU.js";
+import {
+  Link,
+  Outlet,
+  navigate,
+  revalidateNavigation,
+  routeHref,
+  routePath,
+  routeSearchText,
+  routeUrl,
+  useNavigate,
+  useNavigationSnapshot,
+  useRouteMatch
+} from "./chunk-6FI4ROTW.js";
+import {
+  createRequestHandler
+} from "./chunk-EEYASTXR.js";
+import {
+  changes,
+  createStore,
+  createStoreFromEffect,
+  createStoreTag,
+  derive,
+  get,
+  makeStoreLayer,
+  makeStoreLayerFromEffect,
+  modify,
+  select,
+  selectChanges,
+  set,
+  update,
+  useStore,
+  useStoreSelector
+} from "./chunk-NI2GNZ7S.js";
+import {
+  createTestApp
+} from "./chunk-2TG7YEVD.js";
+import {
+  calculateOffsetForIndex,
+  calculateOffsets,
+  calculateTotalSize,
+  calculateVisibleRange,
+  getOffsetForIndex,
+  getTotalSize,
+  getVisibleRange,
+  measureVirtualItems
+} from "./chunk-TUJZ6XJY.js";
+import {
+  defaultHydrationGlobalName,
+  hydrateApp
+} from "./chunk-M2CJG6T7.js";
+import "./chunk-IVIYY6S5.js";
+import {
+  createDevtoolsEventStream,
+  createDevtoolsEventStreamFromTelemetry,
+  createRuntimeEventSource,
+  useDevtoolsEvents,
+  useEventStream
+} from "./chunk-S67FHWAR.js";
+import {
+  createChannel,
+  createPresence,
+  publish,
+  publishAll,
+  subscribe
+} from "./chunk-JKN75OYC.js";
+import {
+  FormValidationError,
+  defineForm,
+  makeForm,
+  useForm
+} from "./chunk-ZMZQBREU.js";
+import "./chunk-2GIUCKL2.js";
+import {
+  cachePolicy,
+  createApp,
+  defineAction,
+  defineLayout,
+  defineManifest,
+  defineMiddleware,
+  definePage,
+  loadersFromManifest,
+  noStore,
+  routesFromManifest
+} from "./chunk-XIBEKS5A.js";
+import {
+  QueryRuntimeError,
+  defineQuery
+} from "./chunk-C5JI7D7W.js";
+import {
+  NavigationCancelledError,
+  NavigationRuntimeError,
+  defineLoader,
+  defineRoute
+} from "./chunk-O7XTA7H3.js";
+import "./chunk-YG22YP5K.js";
+import {
+  defineConfig,
+  resolveConfig
+} from "./chunk-WPV3WFMS.js";
+import "./chunk-SKC3HMF3.js";
+import {
+  defineColumns,
+  filterRows,
+  mapRows,
+  paginateRows,
+  projectRow,
+  projectRows,
+  sortRows
+} from "./chunk-MDGEGQZB.js";
+export {
+  FormValidationError,
+  Link,
+  NavigationCancelledError,
+  NavigationRuntimeError,
+  Outlet,
+  QueryRuntimeError,
+  cachePolicy,
+  calculateOffsetForIndex,
+  calculateOffsets,
+  calculateTotalSize,
+  calculateVisibleRange,
+  changes,
+  createApp,
+  createChannel,
+  createDevtoolsEventStream,
+  createDevtoolsEventStreamFromTelemetry,
+  createPresence,
+  createRequestHandler,
+  createRuntimeEventSource,
+  createStore,
+  createStoreFromEffect,
+  createStoreTag,
+  createTestApp,
+  defaultHydrationGlobalName,
+  defineAction,
+  defineColumns,
+  defineConfig,
+  defineForm,
+  defineLayout,
+  defineLoader,
+  defineManifest,
+  defineMiddleware,
+  definePage,
+  defineQuery,
+  defineRoute,
+  derive,
+  fetchQuery,
+  filterRows,
+  get,
+  getOffsetForIndex,
+  getTotalSize,
+  getVisibleRange,
+  hydrateApp,
+  invalidate,
+  invalidateQuery,
+  loadersFromManifest,
+  makeForm,
+  makeStoreLayer,
+  makeStoreLayerFromEffect,
+  mapRows,
+  measureVirtualItems,
+  modify,
+  navigate,
+  noStore,
+  paginateRows,
+  prefetch,
+  prefetchQuery,
+  projectRow,
+  projectRows,
+  publish,
+  publishAll,
+  resolveConfig,
+  revalidateNavigation,
+  routeHref,
+  routePath,
+  routeSearchText,
+  routeUrl,
+  routesFromManifest,
+  select,
+  selectChanges,
+  set,
+  sortRows,
+  subscribe,
+  update,
+  useDevtoolsEvents,
+  useEventStream,
+  useForm,
+  useInfiniteQuery,
+  useNavigate,
+  useNavigationSnapshot,
+  useQuery,
+  useRouteMatch,
+  useStore,
+  useStoreSelector,
+  useSuspenseQuery
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/kernel/app.d.ts

@@ -0,0 +1,26 @@
+import { Layer } from "effect";
+import { type AnyActionDefinition } from "../actions";
+import type { Actions } from "../actions";
+import type { Boundary } from "../boundary";
+import { type QueryRuntimeOptions } from "../data";
+import type { Data } from "../data";
+import { type AnyLoaderDefinition, type AnyRouteDefinition } from "../navigation";
+import type { Navigation } from "../navigation";
+import { type AppManagedRuntime } from "./runtime";
+import { type TelemetryEvent } from "./telemetry";
+import type { Telemetry } from "./telemetry";
+import type { Stream } from "effect";
+export interface CreateAppLayerOptions {
+    readonly routes: readonly AnyRouteDefinition[];
+    readonly actions?: readonly AnyActionDefinition[];
+    readonly loaders?: readonly AnyLoaderDefinition[];
+    readonly initialHref?: string;
+    readonly data?: QueryRuntimeOptions;
+}
+export type AppServices = Boundary | Data | Actions | Navigation | Telemetry;
+export type AppLayer = Layer.Layer<AppServices, never, never>;
+export declare const createAppLayer: (options: CreateAppLayerOptions) => AppLayer;
+export declare const createAppRuntime: (options: CreateAppLayerOptions) => AppManagedRuntime<AppServices>;
+export interface FrameworkEventStream {
+    readonly stream: Stream.Stream<TelemetryEvent>;
+}

package/dist/kernel/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./runtime";
+export * from "./telemetry";
+export * from "./app";

package/dist/kernel/runtime.d.ts

@@ -0,0 +1,5 @@
+import { ManagedRuntime, type Runtime } from "effect";
+import type { Layer } from "effect";
+export type AppManagedRuntime<R> = ManagedRuntime.ManagedRuntime<R, never>;
+export declare const createManagedRuntime: <R>(layer: Layer.Layer<R, never, never>) => AppManagedRuntime<R>;
+export type RuntimeHandle<R> = Runtime.Runtime<R>;

package/dist/kernel/telemetry.d.ts

@@ -0,0 +1,37 @@
+import { Context, Effect, Layer, Stream } from "effect";
+export type TelemetryEvent = {
+    readonly _tag: "query";
+    readonly phase: "start" | "success" | "failure" | "invalidate";
+    readonly key: string;
+    readonly timestamp: number;
+    readonly detail?: unknown;
+} | {
+    readonly _tag: "navigation";
+    readonly phase: "start" | "success" | "failure" | "cancel";
+    readonly pathname: string;
+    readonly routeId?: string;
+    readonly timestamp: number;
+    readonly detail?: unknown;
+} | {
+    readonly _tag: "action";
+    readonly phase: "start" | "success" | "failure" | "transport";
+    readonly name: string;
+    readonly timestamp: number;
+    readonly detail?: unknown;
+} | {
+    readonly _tag: "boundary";
+    readonly phase: "decode-failure" | "protocol-failure" | "transport-failure";
+    readonly source: string;
+    readonly timestamp: number;
+    readonly detail?: unknown;
+};
+export interface TelemetryService {
+    readonly emit: (event: TelemetryEvent) => Effect.Effect<void>;
+    readonly stream: Stream.Stream<TelemetryEvent>;
+}
+declare const Telemetry_base: Context.TagClass<Telemetry, "EffectReact/Telemetry", TelemetryService>;
+export declare class Telemetry extends Telemetry_base {
+}
+export declare const TelemetryLive: Layer.Layer<Telemetry, never, never>;
+export declare const emitTelemetry: (event: TelemetryEvent) => Effect.Effect<void, never, Telemetry>;
+export {};

package/dist/navigation/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./types";
+export * from "./matcher";
+export * from "./service";
+export * from "./react";

package/dist/navigation/matcher.d.ts

@@ -0,0 +1,13 @@
+import type { AnyRouteDefinition, RouteMatch } from "./types";
+export interface MatchInput {
+    readonly routes: readonly AnyRouteDefinition[];
+    readonly pathname: string;
+    readonly search: unknown;
+}
+export declare const matchRoute: ({ routes, pathname, search }: MatchInput) => RouteMatch<AnyRouteDefinition> | null;
+export declare const buildHref: (pathname: string, searchText: string) => string;
+export declare const normalizeSearchText: (searchText: string) => string;
+export declare const parseHref: (href: string) => {
+    readonly pathname: string;
+    readonly searchText: string;
+};

package/dist/navigation/react.d.ts

@@ -0,0 +1,12 @@
+import { type AnchorHTMLAttributes, type ReactNode } from "react";
+import type { NavigationSnapshot } from "./types";
+export declare const useNavigationSnapshot: () => NavigationSnapshot;
+export declare const useNavigate: () => ((href: string) => Promise<NavigationSnapshot>);
+export interface LinkProps extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>, "href"> {
+    readonly to: string;
+    readonly children?: ReactNode;
+}
+export declare const Link: ({ to, onClick, children, ...rest }: LinkProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Outlet: ({ children }: {
+    readonly children?: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/navigation/service.d.ts

@@ -0,0 +1,23 @@
+import { Context, Effect, Layer, type Stream } from "effect";
+import { Boundary } from "../boundary";
+import { Telemetry } from "../kernel/telemetry";
+import { type AnyLoaderDefinition, type AnyRouteDefinition, type NavigationSnapshot } from "./types";
+import type { NavigationError } from "./types";
+export interface NavigationService {
+    readonly navigate: (href: string) => Effect.Effect<NavigationSnapshot, NavigationError, never>;
+    readonly revalidate: () => Effect.Effect<NavigationSnapshot, NavigationError, never>;
+    readonly getSnapshot: Effect.Effect<NavigationSnapshot, never, never>;
+    readonly hydrateSnapshot: (snapshot: NavigationSnapshot) => Effect.Effect<void, never, never>;
+    readonly snapshots: Stream.Stream<NavigationSnapshot>;
+}
+declare const Navigation_base: Context.TagClass<Navigation, "EffectReact/Navigation", NavigationService>;
+export declare class Navigation extends Navigation_base {
+}
+export interface MakeNavigationLayerOptions {
+    readonly routes: readonly AnyRouteDefinition[];
+    readonly loaders?: readonly AnyLoaderDefinition[];
+    readonly initialHref?: string;
+}
+export declare const makeNavigationLayer: (options: MakeNavigationLayerOptions) => Layer.Layer<Navigation, never, Boundary | Telemetry>;
+export declare const navigateTo: (href: string) => Effect.Effect<NavigationSnapshot, NavigationError, Navigation>;
+export {};

package/dist/navigation/types.d.ts

@@ -0,0 +1,65 @@
+import type { Effect, Schedule, Schema } from "effect";
+import type { BoundaryDecodeError } from "../boundary";
+export interface RouteDefinition<Path extends string, Search, SearchEncoded = Search> {
+    readonly id: string;
+    readonly path: Path;
+    readonly search?: Schema.Schema<Search, SearchEncoded, never>;
+}
+export declare const defineRoute: <Path extends string, Search = Record<never, never>, SearchEncoded = Search>(route: RouteDefinition<Path, Search, SearchEncoded>) => RouteDefinition<Path, Search, SearchEncoded>;
+export interface AnyRouteDefinition {
+    readonly id: string;
+    readonly path: string;
+    readonly search?: Schema.Schema.All;
+}
+export interface RouteMatch<TRoute extends AnyRouteDefinition> {
+    readonly route: TRoute;
+    readonly pathname: string;
+    readonly params: Readonly<Record<string, string>>;
+    readonly search: unknown;
+}
+export interface LoaderContext<TRoute extends AnyRouteDefinition> {
+    readonly route: TRoute;
+    readonly pathname: string;
+    readonly searchText: string;
+    readonly params: Readonly<Record<string, string>>;
+    readonly search: unknown;
+    readonly dependencyResults: Readonly<Record<string, unknown>>;
+}
+export interface LoaderDefinition<Name extends string, RouteId extends string, Output, E, TRoute extends AnyRouteDefinition = AnyRouteDefinition> {
+    readonly name: Name;
+    readonly routeId: RouteId;
+    readonly dependsOn?: readonly string[];
+    readonly retry?: Schedule.Schedule<unknown, E, never>;
+    readonly run: (context: LoaderContext<TRoute>) => Effect.Effect<Output, E, never>;
+}
+export declare const defineLoader: <Name extends string, RouteId extends string, Output, E, TRoute extends AnyRouteDefinition = AnyRouteDefinition>(loader: LoaderDefinition<Name, RouteId, Output, E, TRoute>) => LoaderDefinition<Name, RouteId, Output, E, TRoute>;
+export type AnyLoaderDefinition = LoaderDefinition<string, string, unknown, never, AnyRouteDefinition>;
+export type LoaderSnapshotEntry = {
+    readonly _tag: "pending";
+} | {
+    readonly _tag: "success";
+    readonly value: unknown;
+} | {
+    readonly _tag: "failure";
+    readonly error: unknown;
+};
+export interface NavigationSnapshot {
+    readonly pathname: string;
+    readonly searchText: string;
+    readonly href: string;
+    readonly status: "idle" | "loading" | "success" | "failure";
+    readonly match: RouteMatch<AnyRouteDefinition> | null;
+    readonly loaders: Readonly<Record<string, LoaderSnapshotEntry>>;
+    readonly error: unknown;
+}
+export declare class NavigationRuntimeError extends Error {
+    readonly messageText: string;
+    readonly _tag: "NavigationRuntimeError";
+    constructor(messageText: string);
+}
+export declare class NavigationCancelledError extends Error {
+    readonly pathname: string;
+    readonly _tag: "NavigationCancelledError";
+    constructor(pathname: string);
+}
+export type NavigationError = NavigationRuntimeError | NavigationCancelledError | BoundaryDecodeError;