@notectl/core 0.0.8 → 0.0.10

package/README.md

@@ -32,8 +32,15 @@ Most editors bolt formatting on top of `contenteditable` and hope for the best.
 
 <br />
 
+## Wanna try? 
+Check out the [live playground](http://localhost:4321/notectl/playground/) — no install required.
+
+## Wanna see full working example?
+`examples/vanillajs/` is a great place to see everything in action.
+
 ## Quick Start
 
+
 ### Install
 
 ```bash

package/dist/index.d.ts

@@ -279,6 +279,12 @@ export declare class EditorState {
     }, schema?: Schema): EditorState;
 }
 
+/**
+ * HTML string escaping utilities shared across serialization and parsing.
+ */
+/** Escapes special HTML characters in text content. */
+export declare function escapeHTML(text: string): string;
+
 export declare class EventBus {
     private readonly listeners;
     /** Emits an event to all registered listeners. Errors are caught per listener. */
@@ -699,6 +705,12 @@ export declare interface InlineNodeSpec<T extends string = string> {
     readonly attrs?: Readonly<Record<string, AttrSpec>>;
     /** Group membership (default: 'inline'). For content rules. */
     readonly group?: string;
+    /** Serializes the inline node to an HTML string. */
+    readonly toHTMLString?: (node: InlineNode) => string;
+    /** Rules for matching HTML elements to this inline node type during parsing. */
+    readonly parseHTML?: readonly ParseRule[];
+    /** Tags and attributes this spec needs through DOMPurify sanitization. */
+    readonly sanitize?: SanitizeConfig;
 }
 
 export declare function inlineType(name: string): InlineTypeName;
@@ -920,6 +932,12 @@ export declare interface MarkSpec<T extends string = string> {
     /** Nesting priority — lower rank renders closer to the text content. */
     readonly rank?: number;
     readonly attrs?: Readonly<Record<string, AttrSpec>>;
+    /** Serializes the mark as an HTML wrapper. `content` is the pre-serialized inner HTML. */
+    readonly toHTMLString?: (mark: Mark, content: string) => string;
+    /** Rules for matching HTML elements to this mark type during parsing. */
+    readonly parseHTML?: readonly ParseRule[];
+    /** Tags and attributes this spec needs through DOMPurify sanitization. */
+    readonly sanitize?: SanitizeConfig;
 }
 
 /** @deprecated Use {@link MarkTypeName} for new code. */
@@ -993,6 +1011,14 @@ export declare interface NodeSpec<T extends string = string> {
     readonly group?: string;
     /** If true, selection cannot cross this node's boundary (e.g. table_cell). */
     readonly isolating?: boolean;
+    /** If true, node can be selected as an object via mouse interaction. */
+    readonly selectable?: boolean;
+    /** Serializes the block to an HTML string. `content` is the pre-serialized inline children. */
+    readonly toHTML?: (node: BlockNode, content: string) => string;
+    /** Rules for matching HTML elements to this block type during parsing. */
+    readonly parseHTML?: readonly ParseRule[];
+    /** Tags and attributes this spec needs through DOMPurify sanitization. */
+    readonly sanitize?: SanitizeConfig;
 }
 
 /** @deprecated Use {@link NodeTypeName} for new code. */
@@ -1109,10 +1135,10 @@ export declare class NotectlEditor extends HTMLElement {
     private updateEmptyState;
     private announceFormatChange;
     private replaceState;
-    private blockToHTML;
-    private textNodeToHTML;
+    private serializeBlock;
+    private serializeInlineContent;
+    private serializeTextNode;
     private getMarkOrder;
-    private escapeHTML;
     private parseHTMLToDocument;
     private parseElementToTextNodes;
     private walkElement;
@@ -1134,6 +1160,17 @@ export declare interface NotectlEditorConfig {
     maxHistoryDepth?: number;
 }
 
+/**
+ * ParseRule: describes how an HTML element maps to a document node or mark.
+ * Used by plugins to declare their HTML parsing behavior.
+ */
+export declare interface ParseRule {
+    readonly tag: string;
+    readonly getAttrs?: (el: HTMLElement) => Record<string, unknown> | false;
+    /** Higher priority rules are matched first. Default: 50. */
+    readonly priority?: number;
+}
+
 declare interface Plugin_2<TConfig extends Record<string, unknown> = Record<string, unknown>> {
     readonly id: string;
     readonly name: string;
@@ -1300,6 +1337,15 @@ export declare function resolveParentByPath(doc: Document_2, path: readonly stri
     index: number;
 } | undefined;
 
+/**
+ * SanitizeConfig: declares which HTML tags and attributes a spec needs
+ * to survive DOMPurify sanitization.
+ */
+export declare interface SanitizeConfig {
+    readonly tags?: readonly string[];
+    readonly attrs?: readonly string[];
+}
+
 export declare interface Schema {
     readonly nodeTypes: readonly string[];
     readonly markTypes: readonly string[];
@@ -1350,6 +1396,25 @@ export declare class SchemaRegistry {
     getFileHandlers(): readonly FileHandlerEntry[];
     matchFileHandlers(mimeType: string): FileHandler[];
     removeFileHandler(handler: FileHandler): void;
+    /** Returns all NodeSpec parseHTML rules, sorted by priority descending. */
+    getBlockParseRules(): readonly {
+        readonly rule: ParseRule;
+        readonly type: string;
+    }[];
+    /** Returns all InlineNodeSpec parseHTML rules, sorted by priority descending. */
+    getInlineParseRules(): readonly {
+        readonly rule: ParseRule;
+        readonly type: string;
+    }[];
+    /** Returns all MarkSpec parseHTML rules, sorted by priority descending. */
+    getMarkParseRules(): readonly {
+        readonly rule: ParseRule;
+        readonly type: string;
+    }[];
+    /** Returns all allowed HTML tags from base defaults + all spec sanitize configs. */
+    getAllowedTags(): string[];
+    /** Returns all allowed HTML attributes from base defaults + all spec sanitize configs. */
+    getAllowedAttrs(): string[];
     clear(): void;
 }