edytor 1.0.0-rc.2 → 1.0.0

package/dist/events/nativeInteractiveControl.js

@@ -11,45 +11,24 @@ const findClosestElement = (target, selector) => {
     const element = getElementFromTarget(target);
     return element?.closest(selector) ?? null;
 };
-const getEventPath = (event) => {
-    if (typeof event.composedPath === 'function') {
-        return event.composedPath();
-    }
-    return event.target ? [event.target] : [];
-};
-const getActiveElement = (event) => {
-    const target = getElementFromTarget(event.target);
-    if (target?.ownerDocument.activeElement) {
-        return target.ownerDocument.activeElement;
-    }
-    return typeof document === 'undefined' ? null : document.activeElement;
-};
+/**
+ * A control on the event's path, else the focused one (a link takes no
+ * focus there) when it holds the target or the target holds it.
+ */
 const findNativeControlInEvent = (event, selector) => {
-    for (const target of getEventPath(event)) {
+    for (const target of event.composedPath()) {
         const control = findClosestElement(target, selector);
-        if (control) {
+        if (control)
             return control;
-        }
     }
-    const activeElementSelector = selector === NATIVE_INTERACTIVE_SELECTOR ? NATIVE_ACTIVE_ELEMENT_SELECTOR : selector;
-    const targetControl = findClosestElement(event.target, selector);
-    if (targetControl) {
-        return targetControl;
-    }
-    const targetElement = getElementFromTarget(event.target);
-    const activeElement = getActiveElement(event);
-    const isActiveElementRelatedToTarget = typeof Element !== 'undefined' &&
-        activeElement instanceof Element &&
-        (!targetElement ||
-            activeElement === targetElement ||
-            activeElement.contains(targetElement) ||
-            targetElement.contains(activeElement));
-    return isActiveElementRelatedToTarget
-        ? findClosestElement(activeElement, activeElementSelector)
+    const target = getElementFromTarget(event.target);
+    const active = (target?.ownerDocument ?? globalThis.document)?.activeElement;
+    return active &&
+        (!target || active === target || active.contains(target) || target.contains(active))
+        ? findClosestElement(active, selector === NATIVE_INTERACTIVE_SELECTOR ? NATIVE_ACTIVE_ELEMENT_SELECTOR : selector)
         : null;
 };
 export const isNativeInteractiveControl = (target) => Boolean(findClosestElement(target, NATIVE_INTERACTIVE_SELECTOR));
-export const isNativeFormControl = (target) => Boolean(findClosestElement(target, NATIVE_ACTIVE_ELEMENT_SELECTOR));
 export const isNativeInteractiveEvent = (event) => Boolean(findNativeControlInEvent(event, NATIVE_INTERACTIVE_SELECTOR));
 export const isNativeTextControl = (target) => Boolean(findClosestElement(target, NATIVE_TEXT_SELECTOR));
 export const isNativeTextControlEvent = (event) => Boolean(findNativeControlInEvent(event, NATIVE_TEXT_SELECTOR));
@@ -57,33 +36,19 @@ export const isNativeTextControlEvent = (event) => Boolean(findNativeControlInEv
 // case-sensitive, and "TRUE"/"Plaintext-Only"/"inherit"/garbage values
 // all still establish a nested editable context the guard must catch.
 const EDITABLE_TARGET_SELECTOR = '[contenteditable]:not([contenteditable="false" i])';
-/**
- * The event target sits inside a nested `contenteditable` island that is
- * neither the editor root nor a managed text element (text elements
- * carry their own `contentEditable="true"`). Such islands — a plugin
- * chrome editor, an embedded code field — own their input/composition
- * lifecycle; the outer editor must not snapshot them against the model
- * selection or commit their composition text.
- */
-export const isNestedForeignEditableTarget = (editorRoot, target) => {
-    const editable = findClosestElement(target, EDITABLE_TARGET_SELECTOR);
-    if (!editable || editable === editorRoot) {
-        return false;
-    }
-    return !editable.hasAttribute('data-edytor-text');
-};
 /**
  * A kind's own control: a form control (`input` of any type, `textarea`,
- * `select`, `button`) or a nested editable island inside the host, never the
- * root nor the editor's own text elements. It owns its focus, selection and
- * events; the projector never writes the editor's caret over it.
+ * `select`, `button`) or a nested editable island inside the host (a plugin
+ * chrome editor, an embedded code field: it owns its input and composition
+ * lifecycle), never the root nor the editor's own text elements (they carry
+ * their own `contentEditable="true"`). It owns its focus, selection and
+ * events; the projector never writes the editor's caret over it, and the
+ * editor never snapshots it nor commits its composition text.
  */
 export const isKindControl = (editorRoot, target) => {
-    const element = getElementFromTarget(target);
-    const control = findClosestElement(element, NATIVE_ACTIVE_ELEMENT_SELECTOR) ??
-        (isNestedForeignEditableTarget(editorRoot, element)
-            ? findClosestElement(element, EDITABLE_TARGET_SELECTOR)
-            : null);
+    const editable = findClosestElement(target, EDITABLE_TARGET_SELECTOR);
+    const control = findClosestElement(target, NATIVE_ACTIVE_ELEMENT_SELECTOR) ??
+        (editable?.hasAttribute('data-edytor-text') ? null : editable);
     return Boolean(control && editorRoot && control !== editorRoot && editorRoot.contains(control));
 };
 /**
@@ -95,4 +60,11 @@ export const isKindControl = (editorRoot, target) => {
  * blocks). `onKeyDown`, `onBeforeInput`, `onPaste`, `copySelection` and
  * `onDrop` all ask this.
  */
-export const ownsEvent = (editorRoot, event) => getEventPath(event).some((target) => isKindControl(editorRoot, target));
+export const ownsEvent = (editorRoot, event) => event.composedPath().some((target) => isKindControl(editorRoot, target));
+/**
+ * An event of a native control anywhere (a link, the chrome's buttons beside
+ * the host) or of a kind's own: never the view's own composition or input.
+ */
+export const isControlEvent = (editorRoot, event) => isNativeInteractiveEvent(event) || ownsEvent(editorRoot, event);
+/** A DOM point of the view's own: inside the host and in no kind's own control. */
+export const isOwnPoint = (editorRoot, node) => Boolean(node && editorRoot?.contains(node) && !isKindControl(editorRoot, node));

package/dist/events/onBeforeInput.d.ts

@@ -1,5 +1,10 @@
 import type { Edytor } from '../edytor.svelte.js';
-import { type Occurrence } from '../session/attempt.js';
+import { type Attempt, type Occurrence } from '../session/attempt.js';
+/**
+ * Backspace right after a trailing soft break: the browser mishandles the
+ * `<br>` it renders, so the model deletes the break (a command hooks see).
+ */
+export declare const isTrailingSoftBreakBackward: ({ inputType, yStart, yEnd, startText }: Attempt) => boolean;
 /** An occurrence with no `beforeinput` of its own (paste, drop, a line break found in the DOM). */
 export declare const runOccurrence: (edytor: Edytor, occurrence: Occurrence) => void | Promise<void>;
 /**