edytor 0.1.0-next.43 → 1.0.0-rc.1

package/README.md

@@ -17,7 +17,7 @@
 
 Edytor aims to be for Svelte what Slate.js is for React: a heavily customizable editor with an API to build any kind of collaborative rich text editor.
 
-> **Work in progress.** Edytor is a pre-release (`0.1.0-next.43`, `edytor@next` on npm) and not ready for production; the API changes between releases without a compatibility layer. The untagged `edytor@0.0.11` on npm predates the current API. Issues and PRs are welcome: when you report a bug, include the document's JSON value.
+> **Release candidate.** Edytor `1.0.0-rc.1` is the 1.0 release candidate (`edytor` on npm): its API is frozen, and a change to it before 1.0 is a listed breaking change. It has no production track record yet: read the [limitations](https://edytor.dev/docs/reference/limitations) before you build on it. Issues and PRs are welcome: when you report a bug, include the document's JSON value.
 
 ## Features
 
@@ -42,7 +42,7 @@ Edytor aims to be for Svelte what Slate.js is for React: a heavily customizable
 The pre-release is on npm under the `next` tag. Name the tag: a bare `edytor` is the old, incompatible `0.0.11`.
 
 ```bash
-pnpm add edytor@next
+pnpm add edytor
 ```
 
 `svelte@^5` is a peer dependency. Do not install `yjs`: the v14 engine is vendored (`edytor/crdt`). See [installation](https://edytor.dev/docs/getting-started) and [platform support](https://edytor.dev/docs/reference/platform-support) (Chrome, Edge, Firefox and Safari; real phones are not tested yet).

package/dist/clipboard/insertClipboardFragment.d.ts

@@ -4,6 +4,14 @@ import { type SelectionInsertionTarget, type SelectionReplacementState } from '.
 import { type JSONText } from '../utils/json.js';
 import type { EdytorClipboardFragment } from './types.js';
 export declare const flowOfText: (text: string, marks?: JSONText["marks"]) => Flow;
+/**
+ * A pasted `text/plain` as markdown (`paste.markdown`): `null` unless a line
+ * holds block markdown (`hasBlockMarkdown`), else the blocks it reads as
+ * (`textToBlocks`). A kind the view does not register is a paragraph of its
+ * text, its children after it (a divider is dropped); without a paragraph
+ * kind, nothing converts.
+ */
+export declare const flowOfMarkdown: (edytor: Pick<Edytor, "blocks">, text: string) => Flow | null;
 export declare const flowOfFragment: (fragment: EdytorClipboardFragment) => Flow;
 /**
  * Place `flow` (`flow.*`) at `at`, over the selected blocks (unless

package/dist/clipboard/insertClipboardFragment.js

@@ -4,6 +4,7 @@ import { cloneJsonSafe, jsonBlockToSpec, jsonContentToItems } from '../utils/jso
 import { id } from '../utils.js';
 import { caretAt } from '../session/attempt.js';
 import { isValidEdytorClipboardFragment } from './fragmentData.js';
+import { hasBlockMarkdown, textToBlocks } from './textBlocks.js';
 // Admission (`flow.shape`): every id is minted fresh here, once.
 const run = (content) => ({
     id: id('b'),
@@ -12,6 +13,28 @@ const run = (content) => ({
 export const flowOfText = (text, marks) => ({
     lines: text.split(/\r\n|\r|\n/).map((line) => run(line ? [{ text: line, marks }] : []))
 });
+/**
+ * A pasted `text/plain` as markdown (`paste.markdown`): `null` unless a line
+ * holds block markdown (`hasBlockMarkdown`), else the blocks it reads as
+ * (`textToBlocks`). A kind the view does not register is a paragraph of its
+ * text, its children after it (a divider is dropped); without a paragraph
+ * kind, nothing converts.
+ */
+export const flowOfMarkdown = (edytor, text) => {
+    if (!edytor.blocks.has('paragraph') || !hasBlockMarkdown(text))
+        return null;
+    const known = (block) => {
+        const children = (block.children ?? []).flatMap(known);
+        if (edytor.blocks.has(block.type))
+            return [{ ...block, ...(block.children ? { children } : {}) }];
+        const own = block.type === 'divider' || (!block.content?.length && block.children?.length)
+            ? []
+            : [{ type: 'paragraph', content: block.content ?? [] }];
+        return [...own, ...children];
+    };
+    const blocks = textToBlocks(text).flatMap(known);
+    return blocks.length ? { lines: blocks.map((block) => jsonBlockToSpec(block, true)) } : null;
+};
 export const flowOfFragment = (fragment) => fragment.kind === 'content'
     ? { lines: [run(fragment.content)] }
     : {

package/dist/clipboard/moveText.js

@@ -28,7 +28,7 @@ export const dropText = (edytor, drag, to) => {
     const { copy } = drag;
     /** Nothing written: the range stays selected (the drop's point is not adopted). */
     const keep = () => {
-        edytor.selection.select(drag.range, 'model');
+        edytor.selection.select(drag.range);
         return false;
     };
     // A move onto itself: nothing to write.

package/dist/clipboard/textBlocks.d.ts

@@ -19,5 +19,7 @@ export type TextToBlocksOptions = {
     /** The kind of a paragraph (default `paragraph`). */
     type?: string;
 };
+/** Whether `text` holds block markdown (one line of it is enough), as a paste reads it. */
+export declare const hasBlockMarkdown: (text: string) => boolean;
 /** `text` as blocks (see the module comment). */
 export declare const textToBlocks: (text: string, { markdown, type }?: TextToBlocksOptions) => JSONBlock[];

package/dist/clipboard/textBlocks.js

@@ -21,6 +21,10 @@ const runs = (text) => {
         out.push({ text: text.slice(at) });
     return out;
 };
+/** A line that opens block markdown: a heading, a list or to-do item, a quote, a fence, a divider. */
+const BLOCK_LINE = /^\s*(?:#{1,6}\s|[-*+]\s|\d+[.)]\s|>|```|(?:-{3,}|\*{3,}|_{3,})\s*$)/;
+/** Whether `text` holds block markdown (one line of it is enough), as a paste reads it. */
+export const hasBlockMarkdown = (text) => text.split(/\r?\n/).some((line) => BLOCK_LINE.test(line));
 /** One line's kind, data and text, or `null` for a paragraph line. */
 const lineKind = (line) => {
     let m = /^(#{1,6})\s+(.*)$/.exec(line);

package/dist/cloudflare/DocumentRoom.d.ts

@@ -110,7 +110,7 @@ import { type HistoryEntry, type HistoryOptions, type KVLike, type R2BucketLike
 import type { LockOptions } from './locks.js';
 import type { CommitResult, ExportedBlocks, ImportReceipt, ImportRequest, LateEditBatch, MoveNamespace } from './move.js';
 import type { AwarenessEntry } from '../crdt/protocol.js';
-import type { DocumentSemanticsConfig, EdytorDoc, JSONBlock, JSONDoc, YDoc } from '../crdt/index.js';
+import type { DocumentSemanticsConfig, DocumentOperations, JSONBlock, JSONDoc, YDoc } from '../crdt/index.js';
 import type { CommentActor, CommentChange, CommentOutcome, CommentRequest, CommentSnapshot } from '../crdt/protocols/comments.js';
 /** Under SQLite-backed Durable Objects' 2 MB row cap, with room for the other columns. */
 export declare const DEFAULT_MAX_ROW_BYTES: number;
@@ -481,7 +481,7 @@ export type FrameValidation = {
     /** A block as it is now (`null`: it does not show). */
     after: (id: string) => ValidatedBlock | null;
     /** The live document. Read it; never write from `validate` (defer a `transact` instead). */
-    facade: EdytorDoc;
+    facade: DocumentOperations;
 };
 /** The room's comment threads (`comments` of {@link AttachRoomOptions}). */
 export type CommentOptions = {
@@ -678,7 +678,7 @@ export declare class AttachedDocument {
      * first drops a direct write whose append failed (`heal`), so the next
      * write through it is stored.
      */
-    get facade(): EdytorDoc;
+    get facade(): DocumentOperations;
     /**
      * Manipulate: run `fn` on the facade in one transaction. The edit is
      * stored, then broadcast to every socket. It is not a rollback, like
@@ -695,7 +695,7 @@ export declare class AttachedDocument {
      * without writing: the engine would queue the write until that one
      * ends, so it could not be stored before returning.
      */
-    transact<T>(fn: (facade: EdytorDoc) => T): T;
+    transact<T>(fn: (facade: DocumentOperations) => T): T;
     /** The document as JSON. */
     read(): JSONDoc;
     /**
@@ -1044,10 +1044,10 @@ export declare class DocumentRoom<Env = DocumentRoomEnv> extends DurableObject<E
     /** Generation cutover, also over RPC — see {@link AttachedDocument.reset}. */
     reset(): Promise<void>;
     /** Server-side edit — see {@link AttachedDocument.transact}. */
-    transact<T>(fn: (facade: EdytorDoc) => T): T;
+    transact<T>(fn: (facade: DocumentOperations) => T): T;
     /** The document as JSON. */
     read(): JSONDoc;
-    get facade(): EdytorDoc;
+    get facade(): DocumentOperations;
     get doc(): YDoc | null;
     get failure(): Error | null;
     get refusals(): Refusal[];