@thomasfosterau/effect-richtext 0.0.0-stage → 0.1.0

package/dist/compat/internal/core.d.ts

@@ -0,0 +1,20 @@
+import "effect/Effect";
+/** @internal */
+export declare const CORE: unique symbol;
+/**
+ * Error type raised by `Node.replace` when given an invalid replacement.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare class ReplaceError extends Error {}
+/**
+ * An error thrown when a transform step fails or a structural
+ * transform is invalid.
+ *
+ * @since 0.1.0
+ * @category errors
+ */
+export declare class TransformError extends Error {
+  get name(): string;
+}

package/dist/compat/internal/core.js

@@ -0,0 +1,148 @@
+import * as Arr from "effect/Array";
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Match from "effect/Match";
+import * as Cause from "effect/Cause";
+import * as Exit from "effect/Exit";
+// src/compat/internal/core.ts
+/**
+* Shared machinery of the ProseMirror compatibility layer: the link
+* between facade objects and the core objects they wrap, and the
+* conversion of core errors into ProseMirror's exceptions.
+*
+* Every facade stores its core object under the `CORE` symbol. Core
+* objects are wrapped on demand by `wrap`, which looks up a factory
+* registered for the core object's class (walking the prototype chain)
+* and caches the facade in a `WeakMap`, so that the same core object
+* always yields the same facade.
+*
+* @internal
+*/
+/** @internal */
+const CORE = Symbol.for("effect-richtext/compat/core");
+const facades = /* @__PURE__ */ new WeakMap();
+const factories = /* @__PURE__ */ new WeakMap();
+/** Associate a facade with its core object. @internal */
+const link = (facade, core) => {
+	facade[CORE] = core;
+	facades.set(core, facade);
+	return facade;
+};
+/** Create a facade for `core` without running the facade's constructor. @internal */
+const adopt = (proto, core) => link(Object.create(proto), core);
+/**
+* Register the facade factory for instances of a core class (and its
+* subclasses, unless they have their own factory). @internal
+*/
+const registerWrapper = (coreClass, f) => {
+	factories.set(coreClass.prototype, f);
+};
+/** The facade for a core value (or the value itself if it has none). @internal */
+const wrap = (x) => {
+	if (x === null || typeof x !== "object") return x;
+	const known = facades.get(x);
+	if (known) return known;
+	if (CORE in x) return x;
+	for (let proto = Object.getPrototypeOf(x); proto; proto = Object.getPrototypeOf(proto)) {
+		const f = factories.get(proto);
+		if (f) {
+			const facade = f(x);
+			if (!facades.has(x)) link(facade, x);
+			return facade;
+		}
+	}
+	return x;
+};
+/** The core object behind a facade (or the value itself). @internal */
+const unwrap = (x) => x !== null && typeof x === "object" && CORE in x ? x[CORE] : x;
+/**
+* Core objects created for user subclasses of facade classes are
+* instances of core subclasses whose methods call the facade's
+* overrides. They store the prototype holding the core's own
+* implementations under `BASE`. @internal
+*/
+const BASE = Symbol.for("effect-richtext/compat/base");
+/** Call a core method, bypassing the overrides that delegate to a facade. @internal */
+const callBase = (core, method, args = []) => {
+	const proto = core[BASE];
+	return (proto ? proto[method] : core[method]).apply(core, args);
+};
+/** Read a core getter, bypassing the overrides that delegate to a facade. @internal */
+const getBase = (core, prop) => {
+	for (let proto = core[BASE]; proto; proto = Object.getPrototypeOf(proto)) {
+		const desc = Object.getOwnPropertyDescriptor(proto, prop);
+		if (desc) return desc.get ? desc.get.call(core) : desc.value;
+	}
+	return core[prop];
+};
+/** Whether a value is a facade. @internal */
+const isFacade = (x) => x !== null && typeof x === "object" && CORE in x;
+const arrayFacades = /* @__PURE__ */ new WeakMap();
+const arrayCores = /* @__PURE__ */ new WeakMap();
+/**
+* Wrap an array of core objects, caching the result so that the same
+* core array yields the same facade array. @internal
+*/
+const wrapArray = (arr) => {
+	let found = arrayFacades.get(arr);
+	if (!found) {
+		found = Arr.isReadonlyArrayEmpty(arr) ? emptyFacadeArray : arr.map(wrap);
+		if (found !== emptyFacadeArray) arrayCores.set(found, arr);
+		arrayFacades.set(arr, found);
+	}
+	return found;
+};
+const emptyFacadeArray = [];
+/** Set the core array that the shared empty facade array unwraps to. @internal */
+const setEmptyCoreArray = (core) => {
+	arrayCores.set(emptyFacadeArray, core);
+};
+/** Unwrap an array of facades (reusing the original core array when possible). @internal */
+const unwrapArray = (arr) => {
+	const found = arrayCores.get(arr);
+	if (found) return found;
+	for (let i = 0; i < arr.length; i++) if (isFacade(arr[i])) return arr.map(unwrap);
+	return arr;
+};
+/**
+* Error type raised by `Node.replace` when given an invalid replacement.
+*
+* @since 0.1.0
+* @category errors
+*/
+var ReplaceError = class extends Error {};
+/**
+* An error thrown when a transform step fails or a structural
+* transform is invalid.
+*
+* @since 0.1.0
+* @category errors
+*/
+var TransformError = class extends Error {
+	get name() {
+		return "TransformError";
+	}
+};
+const proseMirrorError = (tag, message) => Match.value(tag).pipe(Match.when("ReplaceError", () => new ReplaceError(message)), Match.whenOr("TransformError", "StepError", () => new TransformError(message)), Match.when("SchemaDefinitionError", () => message.indexOf("(in content expression") > -1 ? new SyntaxError(message) : new RangeError(message)), Match.whenOr("PositionError", "ContentError", "AttributeError", "JSONError", "DOMSpecError", "SelectionError", "StateError", "KeymapError", "ViewError", () => new RangeError(message)), Match.option);
+/** Convert a core (tagged) error into the exception ProseMirror would throw. @internal */
+const convertError = (e) => {
+	if (e === null || typeof e !== "object" || !("_tag" in e) || !Predicate.isString(e._tag)) return e;
+	const message = "message" in e && Predicate.isString(e.message) ? e.message : e._tag;
+	return Option.getOrElse(proseMirrorError(e._tag, message), () => e);
+};
+/** Run `f`, converting core errors into ProseMirror's exceptions. @internal */
+const guard = (f) => {
+	try {
+		return f();
+	} catch (e) {
+		throw convertError(e);
+	}
+};
+/** Run an effect synchronously, throwing (converted) failures and defects. @internal */
+const runSync = (effect) => {
+	const exit = Effect.runSyncExit(effect);
+	if (Exit.isSuccess(exit)) return exit.value;
+	throw convertError(Cause.squash(exit.cause));
+};
+export { BASE, CORE, ReplaceError, TransformError, adopt, callBase, convertError, getBase, guard, isFacade, link, registerWrapper, runSync, setEmptyCoreArray, unwrap, unwrapArray, wrap, wrapArray };

package/dist/compat/internal/props.js

@@ -0,0 +1,82 @@
+import { runSync, unwrap, unwrapArray, wrap, wrapArray } from "./core.js";
+import * as Effect from "effect/Effect";
+// src/compat/internal/props.ts
+/**
+* Translation of ProseMirror-style editor props (functions receiving
+* and returning facades) into core editor props (functions receiving
+* and returning core objects), and back.
+*
+* Arguments are converted with `wrap` and results with `unwrap`, which
+* covers every prop except the few that take callbacks or return
+* objects with methods (`handleTextInput`, `nodeViews`, `markViews`,
+* `handleDOMEvents`), which are handled explicitly. Translations are
+* cached per function/object, so that re-translating the same props
+* yields identical core props (the view compares e.g. node view
+* constructors by identity).
+*
+* @internal
+*/
+const wrapArgs = (args) => {
+	return Array.from(args, (arg) => wrap(arg));
+};
+const unwrapResult = (result) => Array.isArray(result) ? unwrapArray(result) : unwrap(result);
+const cached = (cache, key, make) => {
+	if (!cache) return make();
+	let found = cache.get(key);
+	if (found === void 0) cache.set(key, found = make());
+	return found;
+};
+/** Wrap a ProseMirror-style function so that it can be called with core values. @internal */
+const toCoreFunction = (f, self) => function(...args) {
+	return unwrapResult(f.apply(self, wrapArgs(args)));
+};
+/** Wrap a core function so that it can be called with facades. @internal */
+const fromCoreFunction = (f, self) => function(...args) {
+	let result = f.apply(self, args.map((a) => Array.isArray(a) ? unwrapArray(a) : unwrap(a)));
+	if (Effect.isEffect(result)) result = runSync(result);
+	return Array.isArray(result) ? wrapArray(result) : wrap(result);
+};
+/** Adapt a ProseMirror-style node or mark view object for the core view. @internal */
+const viewObjectToCore = (view) => view && new Proxy(view, { get(target, prop) {
+	const value = target[prop];
+	if (prop === "update" && typeof value === "function") return (node, decorations, inner) => target.update(wrap(node), wrapArray(decorations), wrap(inner));
+	return typeof value === "function" ? value.bind(target) : value;
+} });
+const translateViews = (views, cache) => {
+	const result = {};
+	for (const name in views) {
+		const ctor = views[name];
+		result[name] = ctor && cached(cache, ctor, () => (...args) => viewObjectToCore(ctor(...wrapArgs(args))));
+	}
+	return result;
+};
+/**
+* Translate a set of ProseMirror-style props into core props. Function
+* props are called with `self` as `this`. @internal
+*/
+const propsToCore = (props, self, cache, target = {}) => {
+	for (const name in props) {
+		const value = props[name];
+		if (name === "handleDOMEvents" && value) target[name] = cached(cache, value, () => propsToCore(value, self, cache));
+		else if ((name === "nodeViews" || name === "markViews") && value) target[name] = cached(cache, value, () => translateViews(value, cache));
+		else if (name === "handleTextInput" && typeof value === "function") target[name] = cached(cache, value, () => (view, from, to, text, deflt) => value.call(self, wrap(view), from, to, text, () => wrap(deflt())));
+		else if (name === "plugins" && Array.isArray(value)) target[name] = unwrapArray(value);
+		else if (typeof value === "function") target[name] = cached(cache, value, () => toCoreFunction(value, self));
+		else target[name] = unwrap(value);
+	}
+	return target;
+};
+/** Translate core props into ProseMirror-style props. @internal */
+const propsFromCore = (props, self) => {
+	const target = {};
+	for (const name in props) {
+		const value = props[name];
+		if (name === "handleDOMEvents" && value) target[name] = propsFromCore(value, self);
+		else if (name === "nodeViews" || name === "markViews") target[name] = value;
+		else if (name === "plugins" && Array.isArray(value)) target[name] = wrapArray(value);
+		else if (typeof value === "function") target[name] = fromCoreFunction(value, self);
+		else target[name] = wrap(value);
+	}
+	return target;
+};
+export { fromCoreFunction, propsFromCore, propsToCore, toCoreFunction, viewObjectToCore };

package/dist/compat/keymap.d.ts

@@ -0,0 +1,21 @@
+import { Command, Plugin } from "./state.js";
+import { EditorView } from "./view.js";
+/**
+ * Create a keymap plugin for the given set of bindings.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare function keymap(bindings: {
+  [key: string]: Command;
+}): Plugin;
+/**
+ * Given a set of bindings (using the same format as `keymap`), return a
+ * keydown handler that handles them.
+ *
+ * @since 0.1.0
+ * @category constructors
+ */
+export declare function keydownHandler(bindings: {
+  [key: string]: Command;
+}): (view: EditorView, event: KeyboardEvent) => boolean;

package/dist/compat/keymap.js

@@ -0,0 +1,38 @@
+import { matchBindings, normalizeBindings } from "../keymap/keymap.js";
+import { guard } from "./internal/core.js";
+import { Plugin } from "./state.js";
+// src/compat/keymap.ts
+/**
+* A `prosemirror-keymap`-compatible module. Key names are normalized
+* and matched by the core keymap; the bound ProseMirror-style commands
+* are called directly with the view's `state`, `dispatch` and the view.
+*
+* Ported API surface from prosemirror-keymap (MIT, Marijn Haverbeke and others).
+*
+* @since 0.1.0
+*/
+/**
+* Create a keymap plugin for the given set of bindings.
+*
+* @since 0.1.0
+* @category constructors
+*/
+function keymap(bindings) {
+	return new Plugin({ props: { handleKeyDown: keydownHandler(bindings) } });
+}
+/**
+* Given a set of bindings (using the same format as `keymap`), return a
+* keydown handler that handles them.
+*
+* @since 0.1.0
+* @category constructors
+*/
+function keydownHandler(bindings) {
+	const map = guard(() => normalizeBindings(bindings));
+	return function(view, event) {
+		const candidates = matchBindings(map, event);
+		for (let i = 0; i < candidates.length; i++) if (candidates[i](view.state, view.dispatch, view)) return true;
+		return false;
+	};
+}
+export { keydownHandler, keymap };