@thomasfosterau/effect-richtext 0.0.0 → 0.1.0

package/dist/reactive/stateref.js

@@ -0,0 +1,71 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { acquireSource, publishTransactions, setState, streamsOf } from "./streams.js";
+import * as Effect from "effect/Effect";
+import * as Cause from "effect/Cause";
+import * as Exit from "effect/Exit";
+import * as Semaphore from "effect/Semaphore";
+// src/reactive/stateref.ts
+/**
+* `StateRef`: an editor state held in a `SubscriptionRef`, without a view.
+*
+* @since 0.1.0
+*/
+var stateref_exports = /* @__PURE__ */ __exportAll({
+	StateRefTypeId: () => StateRefTypeId,
+	make: () => make
+});
+/**
+* @since 0.1.0
+* @category symbols
+*/
+const StateRefTypeId = Symbol.for("effect-richtext/reactive/StateRef");
+/**
+* Run a synchronous effect, throwing its squashed cause on failure.
+*/
+const runSyncOrThrow = (effect) => {
+	const exit = Effect.runSyncExit(effect);
+	if (Exit.isFailure(exit)) throw Cause.squash(exit.cause);
+};
+/**
+* Create a `StateRef` holding `initial`. The current context (providing
+* the plugins' requirements `R`) is captured to run plugin hooks when
+* transactions are dispatched. Its streams end when the scope closes.
+*
+* ```ts skip-type-checking
+* const ref = yield* StateRef.make(EditorState.createUnsafe({ schema }))
+* yield* ref.dispatch(ref.state.getUnsafe().tr.insertTextUnsafe("hi"))
+* yield* ref.execute(toggleMark(schema.marks.strong))
+* ```
+*
+* @since 0.1.0
+* @category constructors
+*/
+const make = (initial) => Effect.gen(function* () {
+	const context = yield* Effect.context();
+	const source = yield* acquireSource(initial);
+	const semaphore = Semaphore.makeUnsafe(1);
+	const applyUnlocked = (tr) => Effect.suspend(() => {
+		const prevState = source.ref.value;
+		return Effect.map(prevState.applyTransaction(tr), ({ state, transactions }) => {
+			setState(source, state);
+			publishTransactions(source, transactions, state, prevState);
+		});
+	});
+	const dispatch = (tr) => Effect.provideContext(semaphore.withPermit(applyUnlocked(tr)), context);
+	const dispatchUnsafe = (tr) => runSyncOrThrow(Effect.provideContext(applyUnlocked(tr), context));
+	const set = (state) => semaphore.withPermit(Effect.sync(() => setState(source, state)));
+	const execute = (command) => Effect.suspend(() => {
+		let failure;
+		const commandDispatch = (tr) => failure ? Effect.void : Effect.catchCause(dispatch(tr), (cause) => Effect.sync(() => void (failure = cause)));
+		return Effect.flatMap(command(source.ref.value, commandDispatch), (result) => failure ? Effect.failCause(failure) : Effect.succeed(result));
+	});
+	return {
+		[StateRefTypeId]: StateRefTypeId,
+		...streamsOf(source),
+		dispatch,
+		dispatchUnsafe,
+		set,
+		execute
+	};
+});
+export { StateRefTypeId, make, stateref_exports };

package/dist/reactive/streams.d.ts

@@ -0,0 +1,83 @@
+import { AnySchema, Attrs, MarkNames, MarkType, NodeNames, NodeType } from "../model/schema.js";
+import { Node } from "../model/node.js";
+import "../model.js";
+import { Command, Transaction } from "../state/transaction.js";
+import { Selection } from "../state/selection.js";
+import { EditorState } from "../state/state.js";
+import "../state.js";
+import * as Effect from "effect/Effect";
+import "effect/SubscriptionRef";
+import "effect/PubSub";
+import * as Stream from "effect/Stream";
+import "effect/Scope";
+/**
+ * A transaction applied to an editor state, as emitted by the
+ * `transactions` stream.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface TransactionEvent<Sc extends AnySchema = AnySchema, R = never, E = never> {
+  /** The dispatched transaction. */
+  readonly tr: Transaction<Sc>;
+  /**
+   * All the transactions that were applied: `tr` followed by those
+   * appended by plugins (`appendTransaction`).
+   */
+  readonly transactions: ReadonlyArray<Transaction<Sc>>;
+  /** The state after the transactions were applied. */
+  readonly state: EditorState<Sc, R, E>;
+  /** The state before the transactions were applied. */
+  readonly prevState: EditorState<Sc, R, E>;
+}
+/**
+ * A read-only view of a `SubscriptionRef`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface ReadonlyRef<A> {
+  /** The current value. */
+  readonly get: Effect.Effect<A>;
+  /** The current value, read synchronously. */
+  readonly getUnsafe: () => A;
+  /** The current value followed by every subsequent change. */
+  readonly changes: Stream.Stream<A>;
+}
+/**
+ * The reactive streams of an editor state, shared by `StateRef` (headless)
+ * and `EditorObserver` (bound to a view).
+ *
+ * The state-like streams (`state.changes`, `docChanges`, `selection`,
+ * `select` and the convenience selectors) start with the current value
+ * and only emit when the projected value changes. `transactions` is hot:
+ * subscribers only see the transactions applied after they subscribed.
+ * All streams end when the scope the source was created in closes.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface EditorStreams<Sc extends AnySchema = AnySchema, R = never, E = never> {
+  /** The current state, and its changes. */
+  readonly state: ReadonlyRef<EditorState<Sc, R, E>>;
+  /** The transactions applied to the state (hot). */
+  readonly transactions: Stream.Stream<TransactionEvent<Sc, R, E>>;
+  /** The document, emitted again whenever it changes. */
+  readonly docChanges: Stream.Stream<Node<Sc>>;
+  /** The selection, emitted again whenever it changes (compared with `Selection.eq`). */
+  readonly selection: Stream.Stream<Selection<Sc>>;
+  /**
+   * A projection of the state, emitted again whenever it changes, as
+   * determined by `eq` (default: `Equal.equals`).
+   */
+  readonly select: <A>(f: (state: EditorState<Sc, R, E>) => A, eq?: (self: A, that: A) => boolean) => Stream.Stream<A>;
+  /** Whether a mark is active in the selection (see `isMarkActive`). */
+  readonly isMarkActive: (type: MarkType<Sc, any> | MarkNames<Sc>) => Stream.Stream<boolean>;
+  /** Whether a node is selected or wraps the selection (see `isNodeActive`). */
+  readonly isNodeActive: (type: NodeType<Sc, any> | NodeNames<Sc>, attrs?: Attrs) => Stream.Stream<boolean>;
+  /**
+   * Whether a command can be executed (the command is run without a
+   * dispatch function for each new state).
+   */
+  readonly canExecute: <CE, CR>(command: Command<Sc, CE, CR>) => Stream.Stream<boolean, CE, CR>;
+}

package/dist/reactive/streams.js

@@ -0,0 +1,85 @@
+import { isMarkActive, isNodeActive } from "./selectors.js";
+import * as Effect from "effect/Effect";
+import * as Equal from "effect/Equal";
+import * as SubscriptionRef from "effect/SubscriptionRef";
+import * as PubSub from "effect/PubSub";
+import * as Stream from "effect/Stream";
+// src/reactive/streams.ts
+/**
+* The streams shared by `StateRef` and `EditorObserver`.
+*
+* @since 0.1.0
+*/
+/**
+* Create a `SubscriptionRef` whose pubsub is shut down (ending its
+* `changes` streams) when the scope closes.
+*
+* @internal
+*/
+const acquireRef = (initial) => Effect.acquireRelease(SubscriptionRef.make(initial), (ref) => PubSub.shutdown(ref.pubsub));
+/**
+* Set a `SubscriptionRef` synchronously, publishing the value when it
+* changed (by identity). Used for writes made from synchronous callbacks
+* (view listeners, DOM events, synchronous dispatches).
+*
+* @internal
+*/
+const setRefUnsafe = (ref, value) => {
+	if (ref.value === value) return;
+	ref.value = value;
+	PubSub.publishUnsafe(ref.pubsub, value);
+};
+/**
+* Create the source of the streams; its pubsubs are shut down (ending all
+* streams) when the scope closes.
+*
+* @internal
+*/
+const acquireSource = (initial) => Effect.zipWith(acquireRef(initial), Effect.acquireRelease(PubSub.unbounded(), PubSub.shutdown), (ref, pubsub) => ({
+	ref,
+	pubsub
+}));
+/**
+* Set the current state synchronously (publishing it when it changed).
+*
+* @internal
+*/
+const setState = (source, state) => setRefUnsafe(source.ref, state);
+/**
+* Publish an applied transaction (and the resulting state).
+*
+* @internal
+*/
+const publishTransactions = (source, transactions, state, prevState) => {
+	if (transactions.length) PubSub.publishUnsafe(source.pubsub, {
+		tr: transactions[0],
+		transactions,
+		state,
+		prevState
+	});
+};
+/**
+* Build the streams of a source.
+*
+* @internal
+*/
+const streamsOf = (source, view) => {
+	const { pubsub, ref } = source;
+	const changes = SubscriptionRef.changes(ref);
+	const select = (f, eq = Equal.equals) => Stream.changesWith(Stream.map(changes, f), eq);
+	return {
+		state: {
+			get: SubscriptionRef.get(ref),
+			getUnsafe: () => ref.value,
+			changes
+		},
+		transactions: Stream.fromPubSub(pubsub),
+		docChanges: select((state) => state.doc, (a, b) => a === b),
+		selection: select((state) => state.selection, (a, b) => a.eq(b)),
+		select,
+		isMarkActive: (type) => select((state) => isMarkActive(state, type)),
+		isNodeActive: (type, attrs) => select((state) => isNodeActive(state, type, attrs)),
+		canExecute: (command) => Stream.changesWith(Stream.mapEffect(changes, (state) => command(state, void 0, view)), (a, b) => a === b)
+	};
+};
+export { acquireRef, acquireSource, publishTransactions, setRefUnsafe, setState, streamsOf };

package/dist/reactive.d.ts

@@ -0,0 +1,16 @@
+import { AnySchema } from "./model/schema.js";
+import "./model.js";
+import { EditorView } from "./view/view.js";
+import "./view.js";
+import { EditorObserver, observer_d_exports } from "./reactive/observer.js";
+import { stateref_d_exports } from "./reactive/stateref.js";
+import { isMarkActive, isNodeActive } from "./reactive/selectors.js";
+import { EditorStreams, ReadonlyRef, TransactionEvent } from "./reactive/streams.js";
+/**
+ * Observe an editor view (alias of `EditorObserver.make`).
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare const observe: <Sc extends AnySchema, R, E>(view: EditorView<Sc, R, E>) => import("effect/Effect").Effect<EditorObserver<Sc, R, E>, never, import("effect/Scope").Scope>;
+export { observer_d_exports as EditorObserver, type EditorStreams, type ReadonlyRef, stateref_d_exports as StateRef, type TransactionEvent, isMarkActive, isNodeActive };

package/dist/reactive.js

@@ -0,0 +1,26 @@
+import { make, observer_exports } from "./reactive/observer.js";
+import { stateref_exports } from "./reactive/stateref.js";
+import { isMarkActive, isNodeActive } from "./reactive/selectors.js";
+// src/reactive.ts
+/**
+* Framework-neutral reactive bindings: editor states and views as
+* `SubscriptionRef`s and `Stream`s.
+*
+* - `StateRef.make(state)` holds a state without a view (headless editing,
+*   servers, tests) and applies dispatched transactions.
+* - `EditorObserver.make(view)` (or `observe(view)`) follows a view.
+*
+* Both expose the same `EditorStreams`: `state`, `transactions`,
+* `docChanges`, `selection`, `select(f, eq?)`, `isMarkActive`,
+* `isNodeActive` and `canExecute`.
+*
+* @since 0.1.0
+*/
+/**
+* Observe an editor view (alias of `EditorObserver.make`).
+*
+* @since 0.1.0
+* @category constructors
+*/
+const observe = make;
+export { observer_exports as EditorObserver, stateref_exports as StateRef, isMarkActive, isNodeActive, observe };