@rikalabs/effect-react 0.0.1

package/dist/form/index.cjs

@@ -0,0 +1,301 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/form/index.ts
+var form_exports = {};
+__export(form_exports, {
+  FormValidationError: () => FormValidationError,
+  defineForm: () => defineForm,
+  makeForm: () => makeForm,
+  useForm: () => useForm
+});
+module.exports = __toCommonJS(form_exports);
+
+// src/form/types.ts
+var defineForm = (contract) => contract;
+var FormValidationError = class extends Error {
+  constructor(errors) {
+    super("Form validation failed");
+    this.errors = errors;
+    this.name = "FormValidationError";
+  }
+  _tag = "FormValidationError";
+};
+
+// src/form/service.ts
+var import_effect = require("effect");
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var cloneUnknown = (value) => {
+  if (Array.isArray(value)) {
+    return value.map((entry) => cloneUnknown(entry));
+  }
+  if (isRecord(value)) {
+    const clone = {};
+    for (const [key, entry] of Object.entries(value)) {
+      clone[key] = cloneUnknown(entry);
+    }
+    return clone;
+  }
+  return value;
+};
+var cloneValue = (value) => {
+  return cloneUnknown(value);
+};
+var deepEqual = (left, right) => {
+  if (Object.is(left, right)) {
+    return true;
+  }
+  if (Array.isArray(left) && Array.isArray(right)) {
+    if (left.length !== right.length) {
+      return false;
+    }
+    for (let index = 0; index < left.length; index += 1) {
+      if (!deepEqual(left[index], right[index])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (isRecord(left) && isRecord(right)) {
+    const leftKeys = Object.keys(left);
+    const rightKeys = Object.keys(right);
+    if (leftKeys.length !== rightKeys.length) {
+      return false;
+    }
+    for (const key of leftKeys) {
+      if (!(key in right)) {
+        return false;
+      }
+      if (!deepEqual(left[key], right[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+};
+var toFormErrors = (error, fieldNames) => {
+  const formatted = import_effect.ParseResult.ArrayFormatter.formatErrorSync(error);
+  const errors = {};
+  for (const entry of formatted) {
+    const root = entry.path[0];
+    if (typeof root === "string" && fieldNames.has(root)) {
+      const key = root;
+      errors[key] ??= entry.message;
+      continue;
+    }
+    errors._form ??= entry.message;
+  }
+  if (formatted.length === 0 && errors._form === void 0) {
+    errors._form = "Invalid form values.";
+  }
+  return errors;
+};
+var createInitialState = (defaults) => ({
+  values: cloneValue(defaults),
+  errors: {},
+  touched: {},
+  dirty: false,
+  submitting: false,
+  submitted: false
+});
+var makeForm = (contract) => import_effect.Effect.gen(function* () {
+  const decode = import_effect.Schema.decodeUnknown(contract.schema, { errors: "all" });
+  const defaults = cloneValue(contract.defaults);
+  const fieldNames = new Set(Object.keys(defaults));
+  const snapshots = yield* import_effect.SubscriptionRef.make(createInitialState(defaults));
+  const validateCurrent = (current) => decode(current.values).pipe(
+    import_effect.Effect.match({
+      onFailure: (issue) => ({
+        _tag: "invalid",
+        errors: toFormErrors(issue, fieldNames),
+        issue
+      }),
+      onSuccess: (values) => ({
+        _tag: "valid",
+        values: cloneValue(values)
+      })
+    })
+  );
+  const setField = (field, value) => import_effect.SubscriptionRef.update(snapshots, (current) => {
+    const nextValues = {
+      ...current.values,
+      [field]: value
+    };
+    const nextErrors = {
+      ...current.errors
+    };
+    delete nextErrors[field];
+    return {
+      ...current,
+      values: nextValues,
+      errors: nextErrors,
+      touched: {
+        ...current.touched,
+        [field]: true
+      },
+      dirty: !deepEqual(nextValues, defaults),
+      submitted: false
+    };
+  }).pipe(import_effect.Effect.asVoid);
+  const reset = import_effect.SubscriptionRef.set(
+    snapshots,
+    createInitialState(defaults)
+  ).pipe(import_effect.Effect.asVoid);
+  const validate = import_effect.Effect.gen(function* () {
+    const current = yield* import_effect.SubscriptionRef.get(snapshots);
+    const result = yield* validateCurrent(current);
+    if (result._tag === "valid") {
+      yield* import_effect.SubscriptionRef.update(snapshots, (snapshot) => ({
+        ...snapshot,
+        values: result.values,
+        errors: {},
+        dirty: !deepEqual(result.values, defaults)
+      }));
+    } else {
+      yield* import_effect.SubscriptionRef.update(snapshots, (snapshot) => ({
+        ...snapshot,
+        errors: result.errors
+      }));
+    }
+    return result;
+  });
+  const submit = (handler) => import_effect.Effect.gen(function* () {
+    yield* import_effect.SubscriptionRef.update(snapshots, (current2) => ({
+      ...current2,
+      submitting: true,
+      submitted: false
+    }));
+    const current = yield* import_effect.SubscriptionRef.get(snapshots);
+    const validation = yield* validateCurrent(current);
+    if (validation._tag === "invalid") {
+      yield* import_effect.SubscriptionRef.update(snapshots, (snapshot) => ({
+        ...snapshot,
+        submitting: false,
+        submitted: false,
+        errors: validation.errors
+      }));
+      return yield* import_effect.Effect.fail(new FormValidationError(validation.errors));
+    }
+    yield* import_effect.SubscriptionRef.update(snapshots, (snapshot) => ({
+      ...snapshot,
+      values: validation.values,
+      errors: {},
+      dirty: !deepEqual(validation.values, defaults)
+    }));
+    return yield* handler(validation.values).pipe(
+      import_effect.Effect.tap(
+        () => import_effect.SubscriptionRef.update(snapshots, (snapshot) => ({
+          ...snapshot,
+          submitting: false,
+          submitted: true
+        })).pipe(import_effect.Effect.asVoid)
+      ),
+      import_effect.Effect.tapError(
+        () => import_effect.SubscriptionRef.update(snapshots, (snapshot) => ({
+          ...snapshot,
+          submitting: false,
+          submitted: false
+        })).pipe(import_effect.Effect.asVoid)
+      )
+    );
+  });
+  return {
+    getSnapshot: import_effect.SubscriptionRef.get(snapshots),
+    snapshots: snapshots.changes,
+    setField,
+    reset,
+    validate,
+    submit
+  };
+});
+
+// src/form/react.tsx
+var import_effect2 = require("effect");
+var import_react2 = require("react");
+
+// src/react/provider.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var RuntimeContext = (0, import_react.createContext)(null);
+var useEffectRuntime = () => {
+  const runtime = (0, import_react.useContext)(RuntimeContext);
+  if (runtime === null) {
+    throw new Error("Effect runtime is not available. Wrap your app with <EffectProvider>.");
+  }
+  return runtime;
+};
+
+// src/form/react.tsx
+var useFormStore = (contract) => {
+  const runtime = useEffectRuntime();
+  return (0, import_react2.useMemo)(() => runtime.runSync(makeForm(contract)), [contract, runtime]);
+};
+var useForm = (contract) => {
+  const runtime = useEffectRuntime();
+  const form = useFormStore(contract);
+  const subscribe = (0, import_react2.useCallback)(
+    (listener) => {
+      const fiber = runtime.runFork(import_effect2.Stream.runForEach(form.snapshots, () => import_effect2.Effect.sync(listener)));
+      return () => {
+        runtime.runFork(import_effect2.Fiber.interrupt(fiber));
+      };
+    },
+    [form, runtime]
+  );
+  const getSnapshot = (0, import_react2.useCallback)(() => runtime.runSync(form.getSnapshot), [form, runtime]);
+  const snapshot = (0, import_react2.useSyncExternalStore)(subscribe, getSnapshot, getSnapshot);
+  const setField = (0, import_react2.useCallback)(
+    (field, value) => runtime.runPromise(form.setField(field, value)),
+    [form, runtime]
+  );
+  const reset = (0, import_react2.useCallback)(
+    () => runtime.runPromise(form.reset),
+    [form, runtime]
+  );
+  const validate = (0, import_react2.useCallback)(
+    () => runtime.runPromise(form.validate),
+    [form, runtime]
+  );
+  const submit = (0, import_react2.useCallback)(
+    (handler) => runtime.runPromise(form.submit(handler)),
+    [form, runtime]
+  );
+  return {
+    ...snapshot,
+    commands: {
+      setField: form.setField,
+      reset: form.reset,
+      validate: form.validate,
+      submit: form.submit
+    },
+    setField,
+    reset,
+    validate,
+    submit
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FormValidationError,
+  defineForm,
+  makeForm,
+  useForm
+});
+//# sourceMappingURL=index.cjs.map

package/dist/form/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/form/index.ts","../../src/form/types.ts","../../src/form/service.ts","../../src/form/react.tsx","../../src/react/provider.tsx"],"sourcesContent":["export * from \"./types\";\nexport * from \"./service\";\nexport * from \"./react\";\n","import type { Effect, ParseResult, Schema, Stream } from \"effect\";\n\nexport type FormValues = Readonly<Record<string, unknown>>;\n\nexport type FormFieldName<Values extends FormValues> = Extract<keyof Values, string>;\n\nexport type FormErrorKey<Values extends FormValues> = FormFieldName<Values> | \"_form\";\n\nexport type FormErrors<Values extends FormValues> = Readonly<\n  Partial<Record<FormErrorKey<Values>, string>>\n>;\n\nexport type FormTouched<Values extends FormValues> = Readonly<\n  Partial<Record<FormFieldName<Values>, boolean>>\n>;\n\nexport interface FormContract<Values extends FormValues, Encoded = Values> {\n  readonly schema: Schema.Schema<Values, Encoded, never>;\n  readonly defaults: Values;\n}\n\nexport const defineForm = <Values extends FormValues, Encoded = Values>(\n  contract: FormContract<Values, Encoded>,\n): FormContract<Values, Encoded> => contract;\n\nexport interface FormState<Values extends FormValues> {\n  readonly values: Values;\n  readonly errors: FormErrors<Values>;\n  readonly touched: FormTouched<Values>;\n  readonly dirty: boolean;\n  readonly submitting: boolean;\n  readonly submitted: boolean;\n}\n\nexport type FormValidationResult<Values extends FormValues> =\n  | {\n      readonly _tag: \"valid\";\n      readonly values: Values;\n    }\n  | {\n      readonly _tag: \"invalid\";\n      readonly errors: FormErrors<Values>;\n      readonly issue: ParseResult.ParseError;\n    };\n\nexport class FormValidationError<Values extends FormValues> extends Error {\n  readonly _tag = \"FormValidationError\" as const;\n\n  constructor(readonly errors: FormErrors<Values>) {\n    super(\"Form validation failed\");\n    this.name = \"FormValidationError\";\n  }\n}\n\nexport type FormSubmitHandler<Values extends FormValues, A, E, R = never> = (\n  values: Values,\n) => Effect.Effect<A, E, R>;\n\nexport interface FormStore<Values extends FormValues> {\n  readonly getSnapshot: Effect.Effect<FormState<Values>, never, never>;\n  readonly snapshots: Stream.Stream<FormState<Values>>;\n  readonly setField: <Field extends FormFieldName<Values>>(\n    field: Field,\n    value: Values[Field],\n  ) => Effect.Effect<void, never, never>;\n  readonly reset: Effect.Effect<void, never, never>;\n  readonly validate: Effect.Effect<FormValidationResult<Values>, never, never>;\n  readonly submit: <A, E, R = never>(\n    handler: FormSubmitHandler<Values, A, E, R>,\n  ) => Effect.Effect<A, E | FormValidationError<Values>, R>;\n}\n","import { Effect, ParseResult, Schema, SubscriptionRef } from \"effect\";\nimport {\n  type FormContract,\n  type FormErrorKey,\n  type FormErrors,\n  type FormFieldName,\n  type FormState,\n  type FormStore,\n  FormValidationError,\n  type FormValidationResult,\n  type FormValues,\n} from \"./types\";\n\nconst isRecord = (value: unknown): value is Record<string, unknown> =>\n  typeof value === \"object\" && value !== null && !Array.isArray(value);\n\nconst cloneUnknown = (value: unknown): unknown => {\n  if (Array.isArray(value)) {\n    return value.map((entry) => cloneUnknown(entry));\n  }\n\n  if (isRecord(value)) {\n    const clone: Record<string, unknown> = {};\n    for (const [key, entry] of Object.entries(value)) {\n      clone[key] = cloneUnknown(entry);\n    }\n    return clone;\n  }\n\n  return value;\n};\n\nconst cloneValue = <A>(value: A): A => {\n  return cloneUnknown(value) as A;\n};\n\nconst deepEqual = (left: unknown, right: unknown): boolean => {\n  if (Object.is(left, right)) {\n    return true;\n  }\n\n  if (Array.isArray(left) && Array.isArray(right)) {\n    if (left.length !== right.length) {\n      return false;\n    }\n    for (let index = 0; index < left.length; index += 1) {\n      if (!deepEqual(left[index], right[index])) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  if (isRecord(left) && isRecord(right)) {\n    const leftKeys = Object.keys(left);\n    const rightKeys = Object.keys(right);\n\n    if (leftKeys.length !== rightKeys.length) {\n      return false;\n    }\n\n    for (const key of leftKeys) {\n      if (!(key in right)) {\n        return false;\n      }\n      if (!deepEqual(left[key], right[key])) {\n        return false;\n      }\n    }\n\n    return true;\n  }\n\n  return false;\n};\n\nconst toFormErrors = <Values extends FormValues>(\n  error: ParseResult.ParseError,\n  fieldNames: ReadonlySet<string>,\n): FormErrors<Values> => {\n  const formatted = ParseResult.ArrayFormatter.formatErrorSync(error);\n  const errors: Partial<Record<FormErrorKey<Values>, string>> = {};\n\n  for (const entry of formatted) {\n    const root = entry.path[0];\n    if (typeof root === \"string\" && fieldNames.has(root)) {\n      const key = root as FormFieldName<Values>;\n      errors[key] ??= entry.message;\n      continue;\n    }\n\n    errors._form ??= entry.message;\n  }\n\n  if (formatted.length === 0 && errors._form === undefined) {\n    errors._form = \"Invalid form values.\";\n  }\n\n  return errors;\n};\n\nconst createInitialState = <Values extends FormValues>(defaults: Values): FormState<Values> => ({\n  values: cloneValue(defaults),\n  errors: {} as FormErrors<Values>,\n  touched: {} as FormState<Values>[\"touched\"],\n  dirty: false,\n  submitting: false,\n  submitted: false,\n});\n\nexport const makeForm = <Values extends FormValues, Encoded = Values>(\n  contract: FormContract<Values, Encoded>,\n): Effect.Effect<FormStore<Values>, never, never> =>\n  Effect.gen(function* () {\n    const decode = Schema.decodeUnknown(contract.schema, { errors: \"all\" });\n    const defaults = cloneValue(contract.defaults);\n    const fieldNames = new Set(Object.keys(defaults));\n    const snapshots = yield* SubscriptionRef.make<FormState<Values>>(createInitialState(defaults));\n\n    const validateCurrent = (\n      current: FormState<Values>,\n    ): Effect.Effect<FormValidationResult<Values>, never, never> =>\n      decode(current.values).pipe(\n        Effect.match({\n          onFailure: (issue) => ({\n            _tag: \"invalid\",\n            errors: toFormErrors<Values>(issue, fieldNames),\n            issue,\n          }),\n          onSuccess: (values) => ({\n            _tag: \"valid\",\n            values: cloneValue(values),\n          }),\n        }),\n      );\n\n    const setField: FormStore<Values>[\"setField\"] = (field, value) =>\n      SubscriptionRef.update(snapshots, (current) => {\n        const nextValues = {\n          ...current.values,\n          [field]: value,\n        } as Values;\n\n        const nextErrors: Partial<Record<FormErrorKey<Values>, string>> = {\n          ...current.errors,\n        };\n        delete nextErrors[field];\n\n        return {\n          ...current,\n          values: nextValues,\n          errors: nextErrors,\n          touched: {\n            ...current.touched,\n            [field]: true,\n          },\n          dirty: !deepEqual(nextValues, defaults),\n          submitted: false,\n        };\n      }).pipe(Effect.asVoid);\n\n    const reset: FormStore<Values>[\"reset\"] = SubscriptionRef.set(\n      snapshots,\n      createInitialState(defaults),\n    ).pipe(Effect.asVoid);\n\n    const validate: FormStore<Values>[\"validate\"] = Effect.gen(function* () {\n      const current = yield* SubscriptionRef.get(snapshots);\n      const result = yield* validateCurrent(current);\n\n      if (result._tag === \"valid\") {\n        yield* SubscriptionRef.update(snapshots, (snapshot) => ({\n          ...snapshot,\n          values: result.values,\n          errors: {} as FormErrors<Values>,\n          dirty: !deepEqual(result.values, defaults),\n        }));\n      } else {\n        yield* SubscriptionRef.update(snapshots, (snapshot) => ({\n          ...snapshot,\n          errors: result.errors,\n        }));\n      }\n\n      return result;\n    });\n\n    const submit: FormStore<Values>[\"submit\"] = (handler) =>\n      Effect.gen(function* () {\n        yield* SubscriptionRef.update(snapshots, (current) => ({\n          ...current,\n          submitting: true,\n          submitted: false,\n        }));\n\n        const current = yield* SubscriptionRef.get(snapshots);\n        const validation = yield* validateCurrent(current);\n\n        if (validation._tag === \"invalid\") {\n          yield* SubscriptionRef.update(snapshots, (snapshot) => ({\n            ...snapshot,\n            submitting: false,\n            submitted: false,\n            errors: validation.errors,\n          }));\n\n          return yield* Effect.fail(new FormValidationError(validation.errors));\n        }\n\n        yield* SubscriptionRef.update(snapshots, (snapshot) => ({\n          ...snapshot,\n          values: validation.values,\n          errors: {} as FormErrors<Values>,\n          dirty: !deepEqual(validation.values, defaults),\n        }));\n\n        return yield* handler(validation.values).pipe(\n          Effect.tap(() =>\n            SubscriptionRef.update(snapshots, (snapshot) => ({\n              ...snapshot,\n              submitting: false,\n              submitted: true,\n            })).pipe(Effect.asVoid),\n          ),\n          Effect.tapError(() =>\n            SubscriptionRef.update(snapshots, (snapshot) => ({\n              ...snapshot,\n              submitting: false,\n              submitted: false,\n            })).pipe(Effect.asVoid),\n          ),\n        );\n      });\n\n    return {\n      getSnapshot: SubscriptionRef.get(snapshots),\n      snapshots: snapshots.changes,\n      setField,\n      reset,\n      validate,\n      submit,\n    } satisfies FormStore<Values>;\n  });\n","import { Effect, Fiber, Stream } from \"effect\";\nimport { useCallback, useMemo, useSyncExternalStore } from \"react\";\nimport { useEffectRuntime } from \"../react/provider\";\nimport { makeForm } from \"./service\";\nimport type {\n  FormContract,\n  FormFieldName,\n  FormState,\n  FormStore,\n  FormSubmitHandler,\n  FormValidationResult,\n  FormValues,\n} from \"./types\";\n\nconst useFormStore = <Values extends FormValues, Encoded = Values>(\n  contract: FormContract<Values, Encoded>,\n): FormStore<Values> => {\n  const runtime = useEffectRuntime();\n  return useMemo(() => runtime.runSync(makeForm(contract)), [contract, runtime]);\n};\n\nexport interface UseFormResult<Values extends FormValues> extends FormState<Values> {\n  readonly commands: Pick<FormStore<Values>, \"setField\" | \"reset\" | \"validate\" | \"submit\">;\n  readonly setField: <Field extends FormFieldName<Values>>(\n    field: Field,\n    value: Values[Field],\n  ) => Promise<void>;\n  readonly reset: () => Promise<void>;\n  readonly validate: () => Promise<FormValidationResult<Values>>;\n  readonly submit: <A, E>(handler: FormSubmitHandler<Values, A, E, never>) => Promise<A>;\n}\n\nexport const useForm = <Values extends FormValues, Encoded = Values>(\n  contract: FormContract<Values, Encoded>,\n): UseFormResult<Values> => {\n  const runtime = useEffectRuntime();\n  const form = useFormStore(contract);\n\n  const subscribe = useCallback(\n    (listener: () => void) => {\n      const fiber = runtime.runFork(Stream.runForEach(form.snapshots, () => Effect.sync(listener)));\n\n      return () => {\n        runtime.runFork(Fiber.interrupt(fiber));\n      };\n    },\n    [form, runtime],\n  );\n\n  const getSnapshot = useCallback(() => runtime.runSync(form.getSnapshot), [form, runtime]);\n\n  const snapshot = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);\n\n  const setField = useCallback<UseFormResult<Values>[\"setField\"]>(\n    (field, value) => runtime.runPromise(form.setField(field, value)),\n    [form, runtime],\n  );\n\n  const reset = useCallback<UseFormResult<Values>[\"reset\"]>(\n    () => runtime.runPromise(form.reset),\n    [form, runtime],\n  );\n\n  const validate = useCallback<UseFormResult<Values>[\"validate\"]>(\n    () => runtime.runPromise(form.validate),\n    [form, runtime],\n  );\n\n  const submit = useCallback<UseFormResult<Values>[\"submit\"]>(\n    (handler) => runtime.runPromise(form.submit(handler)),\n    [form, runtime],\n  );\n\n  return {\n    ...snapshot,\n    commands: {\n      setField: form.setField,\n      reset: form.reset,\n      validate: form.validate,\n      submit: form.submit,\n    },\n    setField,\n    reset,\n    validate,\n    submit,\n  };\n};\n","import type { ManagedRuntime } from \"effect\";\nimport { createContext, useContext, useEffect, type ReactNode } from \"react\";\nimport type { AppServices } from \"../kernel/app\";\n\nexport type EffectReactManagedRuntime<R = AppServices> = ManagedRuntime.ManagedRuntime<R, never>;\n\nconst RuntimeContext = createContext<EffectReactManagedRuntime | null>(null);\n\nexport interface EffectProviderProps {\n  readonly runtime: EffectReactManagedRuntime;\n  readonly children?: ReactNode;\n}\n\nexport const EffectProvider = ({ runtime, children }: EffectProviderProps) => {\n  useEffect(\n    () => () => {\n      void runtime.dispose();\n    },\n    [runtime],\n  );\n\n  return <RuntimeContext.Provider value={runtime}>{children}</RuntimeContext.Provider>;\n};\n\nexport const useEffectRuntime = (): EffectReactManagedRuntime => {\n  const runtime = useContext(RuntimeContext);\n  if (runtime === null) {\n    throw new Error(\"Effect runtime is not available. Wrap your app with <EffectProvider>.\");\n  }\n  return runtime;\n};\n"],"mappings":"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","names":["current","import_effect","import_react"]}

package/dist/form/index.d.ts

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

package/dist/form/index.js

@@ -0,0 +1,14 @@
+import {
+  FormValidationError,
+  defineForm,
+  makeForm,
+  useForm
+} from "../chunk-ZMZQBREU.js";
+import "../chunk-2GIUCKL2.js";
+export {
+  FormValidationError,
+  defineForm,
+  makeForm,
+  useForm
+};
+//# sourceMappingURL=index.js.map

package/dist/form/index.js.map

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

package/dist/form/react.d.ts

@@ -0,0 +1,9 @@
+import type { FormContract, FormFieldName, FormState, FormStore, FormSubmitHandler, FormValidationResult, FormValues } from "./types";
+export interface UseFormResult<Values extends FormValues> extends FormState<Values> {
+    readonly commands: Pick<FormStore<Values>, "setField" | "reset" | "validate" | "submit">;
+    readonly setField: <Field extends FormFieldName<Values>>(field: Field, value: Values[Field]) => Promise<void>;
+    readonly reset: () => Promise<void>;
+    readonly validate: () => Promise<FormValidationResult<Values>>;
+    readonly submit: <A, E>(handler: FormSubmitHandler<Values, A, E, never>) => Promise<A>;
+}
+export declare const useForm: <Values extends FormValues, Encoded = Values>(contract: FormContract<Values, Encoded>) => UseFormResult<Values>;

package/dist/form/service.d.ts

@@ -0,0 +1,3 @@
+import { Effect } from "effect";
+import { type FormContract, type FormStore, type FormValues } from "./types";
+export declare const makeForm: <Values extends FormValues, Encoded = Values>(contract: FormContract<Values, Encoded>) => Effect.Effect<FormStore<Values>, never, never>;

package/dist/form/types.d.ts

@@ -0,0 +1,41 @@
+import type { Effect, ParseResult, Schema, Stream } from "effect";
+export type FormValues = Readonly<Record<string, unknown>>;
+export type FormFieldName<Values extends FormValues> = Extract<keyof Values, string>;
+export type FormErrorKey<Values extends FormValues> = FormFieldName<Values> | "_form";
+export type FormErrors<Values extends FormValues> = Readonly<Partial<Record<FormErrorKey<Values>, string>>>;
+export type FormTouched<Values extends FormValues> = Readonly<Partial<Record<FormFieldName<Values>, boolean>>>;
+export interface FormContract<Values extends FormValues, Encoded = Values> {
+    readonly schema: Schema.Schema<Values, Encoded, never>;
+    readonly defaults: Values;
+}
+export declare const defineForm: <Values extends FormValues, Encoded = Values>(contract: FormContract<Values, Encoded>) => FormContract<Values, Encoded>;
+export interface FormState<Values extends FormValues> {
+    readonly values: Values;
+    readonly errors: FormErrors<Values>;
+    readonly touched: FormTouched<Values>;
+    readonly dirty: boolean;
+    readonly submitting: boolean;
+    readonly submitted: boolean;
+}
+export type FormValidationResult<Values extends FormValues> = {
+    readonly _tag: "valid";
+    readonly values: Values;
+} | {
+    readonly _tag: "invalid";
+    readonly errors: FormErrors<Values>;
+    readonly issue: ParseResult.ParseError;
+};
+export declare class FormValidationError<Values extends FormValues> extends Error {
+    readonly errors: FormErrors<Values>;
+    readonly _tag: "FormValidationError";
+    constructor(errors: FormErrors<Values>);
+}
+export type FormSubmitHandler<Values extends FormValues, A, E, R = never> = (values: Values) => Effect.Effect<A, E, R>;
+export interface FormStore<Values extends FormValues> {
+    readonly getSnapshot: Effect.Effect<FormState<Values>, never, never>;
+    readonly snapshots: Stream.Stream<FormState<Values>>;
+    readonly setField: <Field extends FormFieldName<Values>>(field: Field, value: Values[Field]) => Effect.Effect<void, never, never>;
+    readonly reset: Effect.Effect<void, never, never>;
+    readonly validate: Effect.Effect<FormValidationResult<Values>, never, never>;
+    readonly submit: <A, E, R = never>(handler: FormSubmitHandler<Values, A, E, R>) => Effect.Effect<A, E | FormValidationError<Values>, R>;
+}

package/dist/framework/app.d.ts

@@ -0,0 +1,21 @@
+import { type AnyActionDefinition } from "../actions";
+import { type AppServices } from "../kernel/app";
+import type { AppManagedRuntime } from "../kernel/runtime";
+import { type AppManifest } from "./manifest";
+import { type EffectReactConfig, type EffectReactResolvedConfig } from "../config";
+import type { AnyPageDefinition } from "./contracts";
+export interface CreateAppOptions {
+    readonly manifest: AppManifest;
+    readonly config?: EffectReactConfig;
+    readonly initialHref?: string;
+}
+export interface EffectReactApp {
+    readonly manifest: AppManifest;
+    readonly config: EffectReactResolvedConfig;
+    readonly runtime: AppManagedRuntime<AppServices>;
+    readonly actions: readonly AnyActionDefinition[];
+    readonly matchPage: (href: string) => AnyPageDefinition | undefined;
+    readonly handleActionRequest: (request: Request) => Promise<Response>;
+    readonly dispose: () => Promise<void>;
+}
+export declare const createApp: (options: CreateAppOptions) => EffectReactApp;

package/dist/framework/cache.d.ts

@@ -0,0 +1,10 @@
+import type { Duration } from "effect";
+export type CacheMode = "no-store" | "force-cache";
+export interface CachePolicy {
+    readonly mode: CacheMode;
+    readonly ttl?: Duration.DurationInput;
+    readonly tags?: readonly string[];
+    readonly key?: string;
+}
+export declare const cachePolicy: (policy: CachePolicy) => CachePolicy;
+export declare const noStore: () => CachePolicy;

package/dist/framework/contracts.d.ts

@@ -0,0 +1,32 @@
+import type { Effect, Layer } from "effect";
+import type { ComponentType } from "react";
+import type { AnyLoaderDefinition, AnyRouteDefinition } from "../navigation";
+import type { CachePolicy } from "./cache";
+export interface PageDefinition<TRoute extends AnyRouteDefinition = AnyRouteDefinition> {
+    readonly id: string;
+    readonly route: TRoute;
+    readonly loader?: AnyLoaderDefinition;
+    readonly cache?: CachePolicy;
+    readonly component: ComponentType;
+}
+export type AnyPageDefinition = PageDefinition<AnyRouteDefinition>;
+export interface LayoutDefinition {
+    readonly id: string;
+    readonly component: ComponentType<{
+        readonly children?: unknown;
+    }>;
+    readonly loader?: AnyLoaderDefinition;
+}
+export interface MiddlewareDefinition<R = never> {
+    readonly provide?: Layer.Layer<R, never, never>;
+    readonly use: (options: {
+        readonly request: Request;
+        readonly next: () => Effect.Effect<Response, unknown, R>;
+    }) => Effect.Effect<Response, unknown, R>;
+}
+export declare const definePage: <TRoute extends AnyRouteDefinition>(page: PageDefinition<TRoute>) => PageDefinition<TRoute>;
+export declare const defineLayout: (layout: LayoutDefinition) => LayoutDefinition;
+export declare const defineMiddleware: <R>(middleware: MiddlewareDefinition<R>) => MiddlewareDefinition<R>;
+export type { CachePolicy } from "./cache";
+export { defineRoute, defineLoader, type RouteDefinition, type LoaderDefinition, type AnyRouteDefinition, type AnyLoaderDefinition, } from "../navigation";
+export { defineAction, type ActionDefinition, type AnyActionDefinition, } from "../actions";