@dineug/erd-editor 4.2.0 → 5.0.0

package/dist/engine/peer-store.js

@@ -0,0 +1,318 @@
+import { toJson } from "../erd-editor-schema/dist/parser.js";
+import { toDocumentJson } from "../erd-editor-schema/dist/storageForm.js";
+import { arrayHas } from "../utils/arrayHas.js";
+import { compositionActionsFlat } from "../r-html/dist/store/index.js";
+import { changeViewportAction, focusColumnAction, focusTableAction, focusTableEndAction, getLWWAction } from "./modules/editor/atom.actions.js";
+import { safeCallback } from "../utils/safeCallback.js";
+import { initialLoadJsonAction$ } from "./modules/editor/generator.actions.js";
+import { ChangeActionTypes, StreamActionTypes } from "./actions.js";
+import _defineProperty from "../_virtual/_@oxc-project_runtime@0.151.0/helpers/esm/defineProperty.js";
+import { createEngineContext } from "./context.js";
+import { createHistory } from "./history.js";
+import { createRxStore } from "./rx-store.js";
+import { createSharedStore } from "./shared-store.js";
+import { toLoadValue } from "../utils/loadValue.js";
+import { clearSharedTrackers, createFocusPresence } from "./presence.js";
+import { createStreamFlusher } from "./stream-flush.js";
+import { defaultToWidth } from "./to-width.js";
+//#region src/engine/peer-store.ts
+var PeerStoreErrorCode = {
+	readonly: "readonly",
+	destroyed: "destroyed"
+};
+var REFUSALS = {
+	readonly: "the document is readonly, so no edit was made",
+	destroyed: "this document session was closed; open the document again"
+};
+var PeerStoreError = class extends Error {
+	constructor(code, operation) {
+		super(REFUSALS[code]);
+		_defineProperty(this, "code", void 0);
+		_defineProperty(this, "operation", void 0);
+		this.name = "PeerStoreError";
+		this.code = code;
+		this.operation = operation;
+	}
+};
+var hasChangeActionTypes = arrayHas(ChangeActionTypes);
+var hasStreamActionTypes = arrayHas(StreamActionTypes);
+var hasCreateActionTypes = arrayHas([
+	"table.add",
+	"column.add",
+	"memo.add",
+	"index.add",
+	"indexColumn.add",
+	"relationship.add",
+	"tableGroup.add",
+	"dictionary.add"
+]);
+function createCountingHistory(history) {
+	let pushes = 0;
+	let limit = 0;
+	return {
+		history: Object.freeze({
+			get cursor() {
+				return history.cursor;
+			},
+			get size() {
+				return history.size;
+			},
+			hasUndo: history.hasUndo,
+			hasRedo: history.hasRedo,
+			undo: history.undo,
+			redo: history.redo,
+			push: (command) => {
+				pushes++;
+				history.push(command);
+			},
+			clear: history.clear,
+			setLimit: (newLimit) => {
+				limit = newLimit;
+				history.setLimit(newLimit);
+			},
+			clone: history.clone
+		}),
+		getPushes: () => pushes,
+		getLimit: () => limit
+	};
+}
+function focusActions(focus) {
+	if (!focus) return [];
+	const { tableId, columnId, focusType } = focus;
+	if (columnId !== void 0) return [focusColumnAction({
+		tableId,
+		columnId,
+		focusType,
+		$mod: false,
+		shiftKey: false
+	})];
+	return [focusTableAction({
+		tableId,
+		focusType
+	})];
+}
+function createPeerStore({ nickname, toWidth = defaultToWidth, presence = true, readonly = false }) {
+	let counter = null;
+	const rxStore = createRxStore(createEngineContext({
+		toWidth,
+		routes: false
+	}), {
+		manualStreamFlush: true,
+		observable: false,
+		getHistory: (options) => {
+			counter = createCountingHistory(createHistory(options));
+			return counter.history;
+		}
+	});
+	const getPushes = () => counter?.getPushes() ?? 0;
+	const getLimit = () => counter?.getLimit() ?? 0;
+	const sharedStore = createSharedStore(rxStore, { getNickname: () => nickname }, { manualStreamFlush: true });
+	const flusher = createStreamFlusher(rxStore, sharedStore);
+	const subscribers = /* @__PURE__ */ new Set();
+	const editorId = rxStore.state.editor.id;
+	let isReadonly = readonly;
+	let destroyed = false;
+	let sinkUnsubscribe = null;
+	let externalSubscribed = false;
+	let batches = 0;
+	let revertLog = [];
+	let redoStack = [];
+	let grouped = null;
+	rxStore.dispatchSync(changeViewportAction({
+		width: 0,
+		height: 0
+	}));
+	const focusPresence = presence ? createFocusPresence(rxStore) : null;
+	const openSink = () => {
+		if (sinkUnsubscribe) return;
+		sinkUnsubscribe = sharedStore.subscribe((actions) => {
+			if (actions.some((action) => hasChangeActionTypes(action.type))) batches++;
+			for (const fn of Array.from(subscribers)) safeCallback(fn, actions);
+		});
+	};
+	const assertUsable = (operation) => {
+		if (destroyed) throw new PeerStoreError(PeerStoreErrorCode.destroyed, operation);
+	};
+	const assertOutsideGroup = (operation) => {
+		if (grouped) throw new Error(`${operation} cannot run inside a group`);
+	};
+	const assertWritable = (operation) => {
+		assertUsable(operation);
+		if (isReadonly) throw new PeerStoreError(PeerStoreErrorCode.readonly, operation);
+	};
+	const trimRevertLog = () => {
+		const limit = getLimit();
+		if (!limit) return;
+		let entries = revertLog.reduce((sum, { historyEntries }) => sum + historyEntries, 0);
+		while (entries > limit) entries -= revertLog.shift().historyEntries;
+		while (revertLog.length > limit) revertLog.splice(revertLog.findIndex(({ historyEntries }) => !historyEntries), 1);
+	};
+	const dispatch = (compositionActions, options = {}) => {
+		assertWritable("dispatch");
+		openSink();
+		const batchesBefore = batches;
+		const pushesBefore = getPushes();
+		const actions = compositionActionsFlat(rxStore.state, rxStore.context, [...focusActions(options.focus), ...compositionActions]);
+		rxStore.dispatchSync(actions);
+		if (actions.some((action) => hasStreamActionTypes(action.type))) flusher.flush();
+		const report = {
+			label: options.label ?? null,
+			actions: actions.filter((action) => hasChangeActionTypes(action.type)),
+			createdIds: actions.filter((action) => hasCreateActionTypes(action.type)).map((action) => action.payload.id),
+			batches: batches - batchesBefore,
+			historyEntries: getPushes() - pushesBefore
+		};
+		if (grouped) {
+			grouped.unit.historyEntries += report.historyEntries;
+			grouped.dispatched = true;
+		} else revertLog.push({
+			label: report.label,
+			historyEntries: report.historyEntries
+		});
+		if (report.historyEntries) redoStack = [];
+		if (!grouped) trimRevertLog();
+		return report;
+	};
+	const group = (label, run) => {
+		assertWritable("group");
+		if (grouped) return run();
+		const current = {
+			unit: {
+				label,
+				historyEntries: 0
+			},
+			dispatched: false
+		};
+		grouped = current;
+		try {
+			return run();
+		} finally {
+			grouped = null;
+			if (current.dispatched) {
+				revertLog.push(current.unit);
+				trimRevertLog();
+			}
+		}
+	};
+	const replay = (unit, step) => {
+		for (let i = 0; i < unit.historyEntries; i++) step();
+		flusher.flush();
+	};
+	const undo = () => {
+		assertWritable("undo");
+		assertOutsideGroup("undo");
+		openSink();
+		const skipped = [];
+		let unit = revertLog.pop();
+		while (unit && !unit.historyEntries) {
+			if (unit.label !== null) skipped.push(unit.label);
+			unit = revertLog.pop();
+		}
+		if (!unit) return {
+			label: null,
+			entries: 0,
+			skipped
+		};
+		replay(unit, rxStore.undo);
+		redoStack.push(unit);
+		return {
+			label: unit.label,
+			entries: unit.historyEntries,
+			skipped
+		};
+	};
+	const redo = () => {
+		assertWritable("redo");
+		assertOutsideGroup("redo");
+		openSink();
+		const unit = redoStack.pop();
+		if (!unit) return {
+			label: null,
+			entries: 0,
+			skipped: []
+		};
+		replay(unit, rxStore.redo);
+		revertLog.push(unit);
+		return {
+			label: unit.label,
+			entries: unit.historyEntries,
+			skipped: []
+		};
+	};
+	const setInitialValue = (value) => {
+		assertUsable("setInitialValue");
+		assertOutsideGroup("setInitialValue");
+		rxStore.dispatchSync(focusTableEndAction(), initialLoadJsonAction$(toLoadValue(value)));
+		rxStore.resetHistory();
+		revertLog = [];
+		redoStack = [];
+	};
+	const subscribe = (fn) => {
+		assertUsable("subscribe");
+		subscribers.add(fn);
+		if (!externalSubscribed) {
+			externalSubscribed = true;
+			if (sinkUnsubscribe) rxStore.dispatchSync(getLWWAction());
+			else openSink();
+		}
+		return () => {
+			subscribers.delete(fn);
+		};
+	};
+	const receive = (actions) => {
+		if (destroyed) return;
+		sharedStore.dispatchSync(actions);
+	};
+	const flushStreamBuffers = () => {
+		if (destroyed) return;
+		flusher.flush();
+	};
+	const destroy = () => {
+		if (destroyed) return;
+		destroyed = true;
+		focusPresence?.destroy();
+		sinkUnsubscribe?.();
+		sinkUnsubscribe = null;
+		subscribers.clear();
+		sharedStore.destroy();
+		rxStore.destroy();
+		clearSharedTrackers(rxStore.state.editor);
+		revertLog = [];
+		redoStack = [];
+	};
+	return Object.freeze({
+		editorId,
+		get value() {
+			return toDocumentJson(rxStore.state);
+		},
+		get runtimeValue() {
+			return toJson(rxStore.state);
+		},
+		get state() {
+			return rxStore.state;
+		},
+		get isReadonly() {
+			return isReadonly;
+		},
+		get isDestroyed() {
+			return destroyed;
+		},
+		setReadonly: (value) => {
+			isReadonly = value;
+		},
+		setInitialValue,
+		mergeClock: (version) => {
+			rxStore.context.clock.merge(version);
+		},
+		dispatch,
+		receive,
+		group,
+		undo,
+		redo,
+		subscribe,
+		flushStreamBuffers,
+		destroy
+	});
+}
+//#endregion
+export { PeerStoreError, PeerStoreErrorCode, createPeerStore };

package/dist/engine/presence.js

@@ -0,0 +1,45 @@
+import { SHARED_FOCUS_TRACKER_TIMEOUT, getLWWAction, sharedFocusTrackerAction } from "./modules/editor/atom.actions.js";
+import { toSharedFocus, toSharedFocusKey } from "../utils/focus.js";
+//#region src/engine/presence.ts
+var FOCUS_HEARTBEAT_MS = SHARED_FOCUS_TRACKER_TIMEOUT / 3;
+var release = (timer) => {
+	timer?.unref?.();
+};
+var SHARED_TRACKER_MAPS = [
+	"sharedMouseTrackerMap",
+	"sharedFocusTrackerMap",
+	"sharedSelectionTrackerMap",
+	"sharedDragSelectTrackerMap"
+];
+function clearSharedTrackers(editor) {
+	for (const key of SHARED_TRACKER_MAPS) {
+		const trackers = editor[key];
+		for (const id of Object.keys(trackers)) {
+			clearTimeout(trackers[id].timeoutId);
+			Reflect.deleteProperty(trackers, id);
+		}
+	}
+}
+function createFocusPresence(store) {
+	let focusKey = "";
+	const broadcast = (force) => {
+		const focus = toSharedFocus(store.state.editor.focusTable);
+		const key = toSharedFocusKey(focus);
+		if (key === focusKey && !force) return;
+		focusKey = key;
+		store.dispatch(sharedFocusTrackerAction({ focus }));
+	};
+	const unsubscribe = store.subscribe((actions) => {
+		broadcast(actions.some((action) => action.type === getLWWAction.type));
+	});
+	const intervalId = setInterval(() => {
+		focusKey && broadcast(true);
+	}, FOCUS_HEARTBEAT_MS);
+	release(intervalId);
+	return Object.freeze({ destroy: () => {
+		unsubscribe();
+		clearInterval(intervalId);
+	} });
+}
+//#endregion
+export { FOCUS_HEARTBEAT_MS, clearSharedTrackers, createFocusPresence };

package/dist/engine/replication-store.js

@@ -0,0 +1,95 @@
+import { toJson } from "../erd-editor-schema/dist/parser.js";
+import { toDocumentJson } from "../erd-editor-schema/dist/storageForm.js";
+import { arrayHas } from "../utils/arrayHas.js";
+import { changeViewportAction } from "./modules/editor/atom.actions.js";
+import { safeCallback } from "../utils/safeCallback.js";
+import { initialLoadJsonAction$ } from "./modules/editor/generator.actions.js";
+import { ReplicaActionTypes, ReplicaChangeActionTypes } from "./actions.js";
+import { createEngineContext } from "./context.js";
+import { actionsFilter } from "./rx-operators/actionsFilter.js";
+import { createStore } from "./store.js";
+import { createHooks } from "./store-hooks.js";
+import { toLoadValue } from "../utils/loadValue.js";
+import { omit } from "es-toolkit";
+import { Observable, Subject, debounceTime, map } from "rxjs";
+//#region src/engine/replication-store.ts
+var isReplicaChange = arrayHas(ReplicaChangeActionTypes);
+var InternalActionType = { change: "change" };
+function createReplicationStore(context) {
+	const subscriptionSet = /* @__PURE__ */ new Set();
+	const engineContext = createEngineContext({
+		...context,
+		routes: false
+	});
+	const { clock } = engineContext;
+	const store = createStore(engineContext, false);
+	store.dispatchSync(changeViewportAction({
+		width: 0,
+		height: 0
+	}));
+	const hooks = createHooks(store);
+	const dispatch$ = new Subject();
+	const change$ = new Observable((subscriber) => store.subscribe((actions) => subscriber.next(actions))).pipe(actionsFilter(ReplicaChangeActionTypes), debounceTime(200));
+	const observers = /* @__PURE__ */ new Set();
+	let baseline = null;
+	const on = (listeners) => {
+		observers.has(listeners) || observers.add(listeners);
+		return () => {
+			observers.delete(listeners);
+		};
+	};
+	const emit = (type, payload) => {
+		observers.forEach((listeners) => {
+			const listener = Reflect.get(listeners, type);
+			safeCallback(listener, payload);
+		});
+	};
+	const setInitialValue = (value) => {
+		baseline = null;
+		store.dispatchSync(initialLoadJsonAction$(toLoadValue(value)));
+	};
+	const dispatchSync = (actions) => {
+		dispatch$.next([actions].flat());
+	};
+	const dispatch = (actions) => {
+		queueMicrotask(() => dispatchSync(actions));
+	};
+	const destroy = () => {
+		Array.from(subscriptionSet).forEach((sub) => sub.unsubscribe());
+		subscriptionSet.clear();
+		observers.clear();
+		store.destroy();
+		hooks.destroy();
+	};
+	const handleChange = () => {
+		const value = toDocumentJson(store.state);
+		const changed = baseline !== null && value !== baseline;
+		if (baseline !== null) baseline = value;
+		emit(InternalActionType.change, {
+			value,
+			changed
+		});
+	};
+	subscriptionSet.add(change$.subscribe(handleChange)).add(dispatch$.pipe(actionsFilter(ReplicaActionTypes), map((actions) => actions.map((action) => omit(action, ["tags"])))).subscribe((actions) => {
+		if (actions.some(({ type }) => isReplicaChange(type))) baseline ??= toDocumentJson(store.state);
+		const version = clock.getNextVersion();
+		actions.forEach((action) => action.version ??= version);
+		store.dispatchSync(actions);
+		actions.forEach((action) => clock.merge(action.version));
+	}));
+	return Object.freeze({
+		get value() {
+			return toDocumentJson(store.state);
+		},
+		get runtimeValue() {
+			return toJson(store.state);
+		},
+		on,
+		setInitialValue,
+		dispatch,
+		dispatchSync,
+		destroy
+	});
+}
+//#endregion
+export { createReplicationStore };

package/dist/engine/rx-operators/actionsFilter.js

@@ -0,0 +1,14 @@
+import { arrayHas } from "../../utils/arrayHas.js";
+import { notEmptyActions } from "./notEmptyActions.js";
+import { Observable } from "rxjs";
+//#region src/engine/rx-operators/actionsFilter.ts
+var actionsFilter = (actionTypes) => {
+	const has = arrayHas(actionTypes);
+	return (source$) => new Observable((subscriber) => source$.subscribe({
+		next: (actions) => subscriber.next(actions.filter((action) => has(action.type))),
+		error: (err) => subscriber.error(err),
+		complete: () => subscriber.complete()
+	})).pipe(notEmptyActions);
+};
+//#endregion
+export { actionsFilter };

package/dist/engine/rx-operators/bufferCircuitBreaker.js

@@ -0,0 +1,35 @@
+import { Observable } from "rxjs";
+//#region src/engine/rx-operators/bufferCircuitBreaker.ts
+var bufferCircuitBreaker = (openingNotifier$, closingNotifier$) => {
+	return (source$) => new Observable((subscriber) => {
+		let isConnection = false;
+		let pending = [];
+		const flush = () => {
+			const actions = pending.flat();
+			pending = [];
+			actions.length && subscriber.next(actions);
+		};
+		const subscription = source$.subscribe({
+			next: (actions) => {
+				pending.push(actions);
+				isConnection && flush();
+			},
+			error: (error) => subscriber.error(error),
+			complete: () => {
+				flush();
+				subscriber.complete();
+			}
+		});
+		subscription.add(openingNotifier$.subscribe(() => {
+			if (isConnection) return;
+			isConnection = true;
+			flush();
+		}));
+		subscription.add(closingNotifier$.subscribe(() => {
+			isConnection = false;
+		}));
+		return subscription;
+	});
+};
+//#endregion
+export { bufferCircuitBreaker };

package/dist/engine/rx-operators/createSharedStreamActionsCompressor.js

@@ -0,0 +1,24 @@
+import { arrayHas } from "../../utils/arrayHas.js";
+import { pushStreamHistoryMap } from "../history.actions.js";
+import { SharedStreamActionTypes, StreamActionTypes, StreamRegroupColorActionTypes, StreamRegroupMoveActionTypes, StreamRegroupScrollActionTypes } from "../actions.js";
+import { groupByStreamActions } from "./groupByStreamActions.js";
+import { last } from "es-toolkit";
+import { map, throttleTime } from "rxjs";
+//#region src/engine/rx-operators/createSharedStreamActionsCompressor.ts
+var hasStreamActionTypes = arrayHas(StreamActionTypes);
+var hasSharedStreamActionTypes = arrayHas(SharedStreamActionTypes);
+var createSharedStreamActionsCompressor = (streamBufferOperator) => (source$) => source$.pipe(groupByStreamActions(SharedStreamActionTypes, [], throttleTime(100, void 0, {
+	leading: true,
+	trailing: true
+})), map((actions) => hasSharedStreamActionTypes(actions[0]?.type) ? [last(actions)] : actions), groupByStreamActions(StreamActionTypes, [
+	["@@move", StreamRegroupMoveActionTypes],
+	["@@scroll", StreamRegroupScrollActionTypes],
+	["@@color", StreamRegroupColorActionTypes]
+], streamBufferOperator), map((actions) => {
+	if (!hasStreamActionTypes(actions[0]?.type)) return actions;
+	const redoActions = [];
+	for (const key of Object.keys(pushStreamHistoryMap)) pushStreamHistoryMap[key]([], redoActions, actions);
+	return redoActions.length ? redoActions : actions;
+}));
+//#endregion
+export { createSharedStreamActionsCompressor };

package/dist/engine/rx-operators/flushOnNotifier.js

@@ -0,0 +1,6 @@
+import { map, race, switchMap, take, timer } from "rxjs";
+//#region src/engine/rx-operators/flushOnNotifier.ts
+var flushOnNotifier = (notifier$) => (source$) => source$.pipe(switchMap((actions) => notifier$.pipe(take(1), map(() => actions))));
+var quietPeriodOrNotifier = (notifier$, quietMs = 200) => (source$) => source$.pipe(switchMap((actions) => race(timer(quietMs), notifier$.pipe(take(1))).pipe(map(() => actions))));
+//#endregion
+export { flushOnNotifier, quietPeriodOrNotifier };

package/dist/engine/rx-operators/groupByStreamActions.js

@@ -0,0 +1,32 @@
+import { arrayHas } from "../../utils/arrayHas.js";
+import { bHas } from "../../utils/bit.js";
+import { notEmptyActions } from "./notEmptyActions.js";
+import { Observable, buffer, debounceTime, groupBy, map, mergeMap } from "rxjs";
+//#region src/engine/rx-operators/groupByStreamActions.ts
+var NONE_STREAM_KEY = "@@none-stream";
+var createToKey = (has, hasRegroups) => (action) => {
+	const hasRegroup = hasRegroups.find(([, has]) => has(action));
+	return hasRegroup ? hasRegroup[0] : has(action.type) ? action.type : NONE_STREAM_KEY;
+};
+var hasTag = (action, tag) => tag !== void 0 && typeof action.tags === "number" && bHas(action.tags, tag);
+var groupByStreamActions = (streamActionTypes, regroups = [], bufferClosingNotifierOperator = debounceTime(200)) => {
+	const toKey = createToKey(arrayHas(streamActionTypes), regroups.map(([key, types, tag]) => {
+		const hasType = arrayHas(types);
+		return [key, (action) => hasType(action.type) || hasTag(action, tag)];
+	}));
+	return (source$) => new Observable((subscriber) => source$.subscribe({
+		next: (actions) => {
+			const group = actions.reduce((acc, action) => {
+				const key = toKey(action);
+				if (!acc[key]) acc[key] = [];
+				acc[key].push(action);
+				return acc;
+			}, {});
+			Object.values(group).forEach((actions) => subscriber.next(actions));
+		},
+		error: (err) => subscriber.error(err),
+		complete: () => subscriber.complete()
+	})).pipe(notEmptyActions, groupBy((actions) => toKey(actions[0])), mergeMap((group$) => group$.key === NONE_STREAM_KEY ? group$ : group$.pipe(buffer(group$.pipe(bufferClosingNotifierOperator)), map((buff) => buff.flat()))));
+};
+//#endregion
+export { groupByStreamActions };

package/dist/engine/rx-operators/ignoreTagFilter.js

@@ -0,0 +1,17 @@
+import { bHas } from "../../utils/bit.js";
+import { notEmptyActions } from "./notEmptyActions.js";
+import { isNil } from "es-toolkit";
+import { Observable } from "rxjs";
+//#region src/engine/rx-operators/ignoreTagFilter.ts
+var ignoreTagFilter = (tags) => {
+	const predicate = (action) => {
+		return isNil(action.tags) || !tags.some((tag) => bHas(action.tags, tag));
+	};
+	return (source$) => new Observable((subscriber) => source$.subscribe({
+		next: (actions) => subscriber.next(actions.filter(predicate)),
+		error: (err) => subscriber.error(err),
+		complete: () => subscriber.complete()
+	})).pipe(notEmptyActions);
+};
+//#endregion
+export { ignoreTagFilter };

package/dist/engine/rx-operators/lockIgnoreFilter.js

@@ -0,0 +1,20 @@
+import { isSettingLocked } from "../../erd-editor-schema/dist/v3/schema/settings.js";
+import { LockSettingActionTypes } from "../actions.js";
+import { notEmptyActions } from "./notEmptyActions.js";
+import { Observable } from "rxjs";
+//#region src/engine/rx-operators/lockIgnoreFilter.ts
+var lockIgnoreFilter = (getLockSettings) => {
+	const predicate = (lockSettings) => (action) => {
+		const lock = Reflect.get(LockSettingActionTypes, action.type);
+		return !lock || !isSettingLocked(lockSettings, lock);
+	};
+	return (source$) => new Observable((subscriber) => source$.subscribe({
+		next: (actions) => {
+			subscriber.next(actions.filter(predicate(getLockSettings())));
+		},
+		error: (err) => subscriber.error(err),
+		complete: () => subscriber.complete()
+	})).pipe(notEmptyActions);
+};
+//#endregion
+export { lockIgnoreFilter };

package/dist/engine/rx-operators/notEmptyActions.js

@@ -0,0 +1,5 @@
+import { filter } from "rxjs";
+//#region src/engine/rx-operators/notEmptyActions.ts
+var notEmptyActions = filter((actions) => Boolean(actions.length));
+//#endregion
+export { notEmptyActions };

package/dist/engine/rx-operators/readonlyIgnoreFilter.d.ts

@@ -1,4 +1,9 @@
 import { AnyAction } from '@dineug/r-html';
 import { Observable } from 'rxjs';
-export declare const readonlyIgnoreFilter: (getReadonly: () => boolean, passTags?: number[]) => (source$: Observable<Array<AnyAction>>) => Observable<AnyAction[]>;
+/**
+ * Drops the edits a readonly host refuses while it is readonly: the
+ * ReadonlyIgnoreActionTypes, the extra types given and each action the extra
+ * predicate names. An action that carries a pass tag goes through regardless.
+ */
+export declare const readonlyIgnoreFilter: (getReadonly: () => boolean, passTags?: number[], extraTypes?: ReadonlyArray<string>, dropsAlso?: (action: AnyAction) => boolean) => (source$: Observable<Array<AnyAction>>) => Observable<AnyAction[]>;
 //# sourceMappingURL=readonlyIgnoreFilter.d.ts.map

package/dist/engine/rx-operators/readonlyIgnoreFilter.js

@@ -0,0 +1,23 @@
+import { arrayHas } from "../../utils/arrayHas.js";
+import { bHas } from "../../utils/bit.js";
+import { ReadonlyIgnoreActionTypes } from "../actions.js";
+import { notEmptyActions } from "./notEmptyActions.js";
+import { isNil } from "es-toolkit";
+import { Observable } from "rxjs";
+//#region src/engine/rx-operators/readonlyIgnoreFilter.ts
+var dropsNothingElse = () => false;
+var readonlyIgnoreFilter = (getReadonly, passTags = [], extraTypes = [], dropsAlso = dropsNothingElse) => {
+	const has = arrayHas([...ReadonlyIgnoreActionTypes, ...extraTypes]);
+	const predicate = (action) => {
+		return !isNil(action.tags) && passTags.some((tag) => bHas(action.tags, tag)) || !(has(action.type) || dropsAlso(action));
+	};
+	return (source$) => new Observable((subscriber) => source$.subscribe({
+		next: (actions) => {
+			subscriber.next(getReadonly() ? actions.filter(predicate) : actions);
+		},
+		error: (err) => subscriber.error(err),
+		complete: () => subscriber.complete()
+	})).pipe(notEmptyActions);
+};
+//#endregion
+export { readonlyIgnoreFilter };

package/dist/engine/rx-operators/readonlyScreenTag.d.ts

@@ -0,0 +1,16 @@
+import { AnyAction } from '@dineug/r-html';
+import { Observable } from 'rxjs';
+import { RootState } from '../state';
+/**
+ * The first writable placement after a readonly screen moved the viewport is
+ * led by where the screen stands, absolute and recording no undo entry, so a
+ * replica and a peer that never heard the screen take its pan from there.
+ */
+export declare function alignViewport(actions: Array<AnyAction>, state: RootState): Array<AnyAction>;
+/**
+ * Tags each setting a readonly reader turns as its own screen's (Tag.screen),
+ * a peer's and a follow left as they are. Pure by contract, as
+ * viewActionRedirect is: it maps the same batch and state to equal output.
+ */
+export declare const readonlyScreenTag: (getReadonly: () => boolean, getState: () => RootState) => (source$: Observable<Array<AnyAction>>) => Observable<AnyAction[]>;
+//# sourceMappingURL=readonlyScreenTag.d.ts.map