@nerd-bible/wordgard 0.3.3

package/dist/types.d.ts

@@ -0,0 +1,196 @@
+import { Mark, Plot, Leaf } from 'wordgard/doc';
+
+/**
+A paragraph. Part of the {@link Node.Group.Content | `Content`}
+group, allowing inline content, rendered as `<p>`.
+*/
+declare const Paragraph: Plot.Tag<null>;
+/**
+Heading plot. Its parameter indicates the heading level. In the
+{@link Node.Group.Content | `Content`} group, allows inline
+content, rendered as `<h1>` to `<h6>`.
+*/
+declare const Heading: Plot.Type<number>;
+/**
+A code block. Part of the {@link Node.Group.Content | `Content`}
+group, with the {@link Node.Role.Code | `Code`} role. Rendered
+as `<pre>`.
+*/
+declare const CodeBlock: Plot.Tag<null>;
+/**
+A mark that assigns a language identifier (any string) to a code
+block. Stored in the `data-language` attribute.
+*/
+declare const CodeBlockLanguage: Mark.Type<string>;
+/**
+Blockquote plot. Allows any {@link Node.Group.Content | `Content`}
+blocks inside of it, and is itself part of that group. Rendered as
+`<blockquote>`.
+*/
+declare const Blockquote: Plot.Tag<null>;
+/**
+Block list item. Allows any {@link Node.Group.Content | `Content`}
+blocks as content. Rendered as `<li>`.
+*/
+declare const ListItem: Plot.Tag<null>;
+/**
+List item with inline content. You'll want to have either this
+plot type or {@link ListItem} in your schema, not both. Rendered
+as `<li>`.
+*/
+declare const InlineListItem: Plot.Tag<null>;
+/**
+Ordered list plot. Part of the {@link Node.Group.Content |
+`Content`} group, allows either {@link ListItem} or {@link
+InlineListItem} as content. Rendered as `<ol>`, with the parameter
+providing the `start` attribute.
+*/
+declare const OrderedList: Plot.Type<number>;
+/**
+An unordered list. Defaults to the {@link Node.Group.Content |
+`Content`} group. Allows {@link ListItem} or {@link
+InlineListItem} as content. Rendered as `<ul>`.
+*/
+declare const BulletList: Plot.Tag<null>;
+/**
+A horizontal separator. Part of the {@link Node.Group.Content |
+`Content`} group. Renders as `<hr>`.
+*/
+declare const HorizontalRule: Leaf<null>;
+/**
+A hard line break. Renders as `<br>` and has the {@link
+Node.Role.LineBreak | `LineBreak`} role.
+*/
+declare const LineBreak: Leaf<null>;
+/**
+Table cell plot. Allows inline content, and is in the {@link
+Node.Group.TableCell | `TableCell`} group. Rendered as `<td>`
+*/
+declare const Cell: Plot.Tag<null>;
+/**
+Table header cell. Like {@link Cell}, but rendered as `<th>`.
+*/
+declare const HeaderCell: Plot.Tag<null>;
+/**
+Table cell with block content. Rendered as `<td>`. You can use
+either this one or {@link Cell} in your schema, not both.
+*/
+declare const BlockCell: Plot.Tag<null>;
+/**
+Table header cell with block content. Rendered as `<th>`.
+*/
+declare const BlockHeaderCell: Plot.Tag<null>;
+/**
+Table row. Allows nodes with the {@link Node.Group.TableCell |
+`TableCell`} group as content. Rendered as `<tr>`.
+*/
+declare const TableRow: Plot.Tag<null>;
+/**
+A table. Contains {@link TableRow}s, is part of the {@link
+Node.Group.Content | `Content`} group. Rendered as
+`<table><tbody>`.
+*/
+declare const Table: Plot.Tag<null>;
+/**
+Table cell column span. Rendered with the `colspan` attribute.
+Must hold a positive integer. Is assumed
+to be 1 when missing.
+*/
+declare const ColSpan: Mark.Type<number>;
+/**
+Table cell row span. Rendered with the `rowspan` attribute.
+Is assumed to be 1 when missing.
+*/
+declare const RowSpan: Mark.Type<number>;
+/**
+An inline image leaf. The string parameter is the image's source
+URI. Rendered as `<img>`.
+*/
+declare const Image: Leaf.Type<string>;
+/**
+A block image leaf. Renders as a `<figure>` element with an
+`<img>` in it. The parameter holds the image URI.
+*/
+declare const Figure: Leaf.Type<string>;
+/**
+A textblock plot representing a captioned image. The image URI is
+the plot's parameter, and the caption the content (inline).
+Assigned to the {@link Node.Group.Content | `Content`} group by
+default. Renders as a `<figure>` element with `<img>` and
+`<figcaption>` elements as children.
+*/
+declare const CaptionedFigure: Plot.Type<string>;
+/**
+Image alt text. Renders as an `alt` attribute.
+*/
+declare const ImageAlt: Mark.Type<string>;
+/**
+Image size, as a width in pixels. Renders as a `width` style.
+*/
+declare const ImageSize: Mark.Type<number>;
+/**
+Text alignment. Applies to any textblock or figure. Not having
+this mark implies aligning to the start of the block. Renders as a
+`text-align` style.
+*/
+declare const Alignment: Mark.Type<"center" | "end">;
+/**
+The text direction for a textblock. Not having this mark means the
+document's base direction is used. `"auto"` means the direction is
+derived from the first character in the block that has a strong
+direction. Rendered using the `dir` attribute.
+*/
+declare const Direction: Mark.Type<"auto" | "ltr" | "rtl">;
+/**
+Emphasis mark. Rendered using the `<em>` element.
+*/
+declare const Emphasis: Mark<null>;
+/**
+Strong emphasis mark. Rendered using the `<strong>` element.
+*/
+declare const Strong: Mark<null>;
+/**
+Underline mark. Rendered using `<u>`.
+*/
+declare const Underline: Mark<null>;
+/**
+Strikethrough mark. Rendered as an `<s>` element.
+*/
+declare const Strikethrough: Mark<null>;
+/**
+Superscript text. Rendered using `<sup>`.
+*/
+declare const Superscript: Mark<null>;
+/**
+Subscript text. Rendered using `<sub>`.
+*/
+declare const Subscript: Mark<null>;
+/**
+Link markup. The parameter is the link's target. Rendered as an
+`<a>` element with the target in `href`.
+*/
+declare const Link: Mark.Type<string>;
+/**
+Code font text. Rendered as `<code>`.
+*/
+declare const Code: Mark<null>;
+/**
+Text color mark. Rendered with the `color` style.
+*/
+declare const Color: Mark.Type<string>;
+/**
+Text background color. Rendered with the `background-color` style.
+*/
+declare const BackgroundColor: Mark.Type<string>;
+/**
+A document type that allows any {@link Node.Group.Content |
+`Content` group} nodes as content.
+*/
+declare const Doc: Plot.Type<null>;
+/**
+A document type that has inline content, so the entire document is
+a single textblock.
+*/
+declare const InlineDoc: Plot.Type<null>;
+
+export { Alignment, BackgroundColor, BlockCell, BlockHeaderCell, Blockquote, BulletList, CaptionedFigure, Cell, Code, CodeBlock, CodeBlockLanguage, ColSpan, Color, Direction, Doc, Emphasis, Figure, HeaderCell, Heading, HorizontalRule, Image, ImageAlt, ImageSize, InlineDoc, InlineListItem, LineBreak, Link, ListItem, OrderedList, Paragraph, RowSpan, Strikethrough, Strong, Subscript, Superscript, Table, TableRow, Underline };

package/dist/types.js

@@ -0,0 +1,288 @@
+import { Node, Plot, Elt, ValidationError, Mark, Leaf, parse } from 'wordgard/doc';
+
+const G = /*@__PURE__*/(() => Node.Group)();
+const Paragraph = /*@__PURE__*/(() => Plot.define("Paragraph", {
+    inlineContent: true,
+    group: G.Content,
+    defaultBlock: true,
+    shape: { element: "p" }
+}))();
+const Heading = /*@__PURE__*/(() => Plot.Type.define("Heading", {
+    defaultParam: 1,
+    validate: value => {
+        if (typeof value != "number" || Math.floor(value) != value || value < 1 || value > 6)
+            throw new ValidationError(`Invalid heading level: ${value}`);
+    },
+    inlineContent: true,
+    group: G.Content,
+    shape: { structure: level => Elt.mk("h" + level, [0]), atom: false },
+    defining: true,
+    parseRules: [
+        { selector: "h1", param: 1 },
+        { selector: "h2", param: 2 },
+        { selector: "h3", param: 3 },
+        { selector: "h4", param: 4 },
+        { selector: "h5", param: 5 },
+        { selector: "h6", param: 6 },
+    ]
+}))();
+const CodeBlock = /*@__PURE__*/(() => Plot.define("CodeBlock", {
+    inlineContent: true,
+    group: G.Content,
+    role: Node.Role.Code,
+    shape: { element: "pre" },
+}))();
+const CodeBlockLanguage = /*@__PURE__*/Mark.Type.define("CodeBlockLanguage", {
+    target: CodeBlock,
+    validate: "string",
+    shape: { attribute: "data-language", value: 0 }
+});
+const Blockquote = /*@__PURE__*/(() => Plot.define("Blockquote", {
+    blockContent: G.Content,
+    group: G.Content,
+    shape: { element: "blockquote" },
+    autoJoin: true
+}))();
+const ListItem = /*@__PURE__*/(() => Plot.define("ListItem", {
+    blockContent: G.Content,
+    shape: { element: "li" },
+    defining: true,
+}))();
+const InlineListItem = /*@__PURE__*/Plot.define("ListItem", {
+    inlineContent: true,
+    shape: { element: "li" },
+    defining: true,
+});
+const OrderedList = /*@__PURE__*/(() => Plot.Type.define("OrderedList", {
+    defaultParam: 1,
+    validate: "number",
+    blockContent: [ListItem, InlineListItem],
+    group: G.Content,
+    role: Node.Role.List,
+    defining: true,
+    shape: {
+        element: "ol",
+        attributes: start => start == 1 ? {} : { start: String(start) },
+        readElement: elt => Number(elt.getAttribute("start") || "1")
+    },
+    autoJoin: (_a, b) => b.param == 1
+}))();
+const BulletList = /*@__PURE__*/(() => Plot.define("BulletList", {
+    blockContent: [ListItem, InlineListItem],
+    group: G.Content,
+    role: Node.Role.List,
+    defining: true,
+    shape: { element: "ul" },
+    autoJoin: true
+}))();
+const HorizontalRule = /*@__PURE__*/(() => Leaf.define("HorizontalRule", {
+    group: G.Content,
+    shape: { element: "hr" },
+    toText: () => "---",
+    selectable: true
+}))();
+const LineBreak = /*@__PURE__*/(() => Leaf.define("LineBreak", {
+    inline: true,
+    role: Node.Role.LineBreak,
+    toText: () => "\n",
+    shape: { element: "br" }
+}))();
+const Cell = /*@__PURE__*/(() => Plot.define("Cell", {
+    inlineContent: true,
+    group: G.TableCell,
+    isolating: true,
+    cursorBarrier: false,
+    shape: { element: "td" }
+}))();
+const HeaderCell = /*@__PURE__*/(() => Plot.define("HeaderCell", {
+    inlineContent: true,
+    group: G.TableCell,
+    isolating: true,
+    cursorBarrier: false,
+    shape: { element: "th" }
+}))();
+const BlockCell = /*@__PURE__*/(() => Plot.define("Cell", {
+    blockContent: G.Content,
+    group: G.TableCell,
+    isolating: true,
+    cursorBarrier: false,
+    shape: { element: "td" }
+}))();
+const BlockHeaderCell = /*@__PURE__*/(() => Plot.define("HeaderCell", {
+    blockContent: G.Content,
+    group: G.TableCell,
+    isolating: true,
+    cursorBarrier: false,
+    shape: { element: "th" }
+}))();
+const TableRow = /*@__PURE__*/(() => Plot.define("TableRow", {
+    blockContent: G.TableCell,
+    canBeEmpty: true,
+    orientation: "row",
+    shape: { element: "tr" }
+}))();
+const Table = /*@__PURE__*/(() => Plot.define("Table", {
+    blockContent: TableRow,
+    isolating: true,
+    group: G.Content,
+    shape: { structure: Elt.mk("table", [Elt.mk("tbody", [0])]) },
+    parseRules: [{ selector: "table" }]
+}))();
+function validatePosInt(value) {
+    if (typeof value != "number" || Math.round(value) != value || value < 1)
+        throw new RangeError(`${value} is not a positive integer`);
+}
+function readPosInt(value) {
+    let num = Number.parseInt(value);
+    if (Number.isNaN(num) || num < 1)
+        return parse.Reject;
+    return num;
+}
+const ColSpan = /*@__PURE__*/(() => Mark.Type.define("ColSpan", {
+    target: G.TableCell,
+    validate: validatePosInt,
+    shape: { attribute: "colspan", value: span => String(span), readAttribute: readPosInt }
+}))();
+const RowSpan = /*@__PURE__*/(() => Mark.Type.define("RowSpan", {
+    target: G.TableCell,
+    validate: validatePosInt,
+    shape: { attribute: "rowspan", value: span => String(span), readAttribute: readPosInt }
+}))();
+const Image = /*@__PURE__*/Leaf.Type.define("Image", {
+    inline: true,
+    validate: "string",
+    shape: { element: "img", attributes: src => ({ src }) },
+    selectable: true,
+    parseRules: [{
+            selector: "img[src]",
+            readElement: elt => elt.src
+        }]
+});
+const Figure = /*@__PURE__*/(() => Leaf.Type.define("Figure", {
+    validate: "string",
+    shape: { structure: src => Elt.mk("figure", [Elt.mk("img", { src })]) },
+    selectable: true,
+    group: G.Content,
+    parseRules: [{
+            selector: "figure:has(img[src])",
+            marksFrom: "img[src]",
+            readElement: elt => elt.querySelector("img[src]").src,
+            precedence: 2
+        }]
+}))();
+const CaptionedFigure = /*@__PURE__*/(() => Plot.Type.define("CaptionedFigure", {
+    inlineContent: true,
+    validate: "string",
+    shape: { structure: src => Elt.mk("figure", [Elt.mk("img", { src }), Elt.mk("figcaption", [0])]), atom: false },
+    group: G.Content,
+    parseRules: [{
+            selector: "figure:has(img[src]):has(figcaption)",
+            marksFrom: "img[src]",
+            readElement: elt => elt.querySelector("img[src]").src,
+            contentElement: "figcaption",
+            precedence: 4
+        }]
+}))();
+const ImageAlt = /*@__PURE__*/Mark.Type.define("ImageAlt", {
+    target: [Image, Figure, CaptionedFigure],
+    validate: "string",
+    shape: { attribute: "alt", value: 0, preferTarget: "img" }
+});
+const ImageSize = /*@__PURE__*/Mark.Type.define("ImageSize", {
+    target: [Image, Figure, CaptionedFigure],
+    validate: "number",
+    shape: { attribute: "style", value: size => `width: ${size}px`, preferTarget: "img" }
+});
+const Alignment = /*@__PURE__*/(() => Mark.Type.define("Alignment", {
+    target: [G.Textblock, Figure],
+    keepOnSplit: true,
+    keepOnTypeChange: true,
+    shape: { attribute: "style", value: align => `text-align: ${align}` },
+    parseRules: [
+        { attribute: "style/text-align", readAttribute: value => /^(end|center)$/.test(value) ? value : parse.Reject }
+    ]
+}))();
+const Direction = /*@__PURE__*/(() => Mark.Type.define("Direction", {
+    target: G.Textblock,
+    keepOnSplit: true,
+    keepOnTypeChange: true,
+    validate: val => {
+        if (val != "ltr" && val != "rtl" && val != "auto")
+            throw new ValidationError(`Invalid direction value: ${val}`);
+    },
+    shape: { attribute: "dir", value: 0 }
+}))();
+const Emphasis = /*@__PURE__*/Mark.define("Emphasis", {
+    rank: 50,
+    shape: { element: "em" },
+    parseRules: [
+        { attribute: "style/font-style", value: "italic" },
+        { attribute: "style/font-style", value: "normal", clearMark: p => p.name == "Emphasis" }
+    ]
+});
+const Strong = /*@__PURE__*/Mark.define("Strong", {
+    rank: 60,
+    shape: { element: "strong" },
+    parseRules: [
+        { attribute: "style/font-weight",
+            readAttribute: value => /^(bold(er)?|[5-9]\d{2,})$/.test(value) ? null : parse.Reject },
+        { attribute: "style/font-weight",
+            readAttribute: value => /^(normal|lighter|[1-4]\d{2})$/.test(value) ? null : parse.Reject,
+            clearMark: p => p.name == "Strong" },
+    ]
+});
+const Underline = /*@__PURE__*/Mark.define("Underline", {
+    rank: 40,
+    shape: { element: "u" },
+    parseRules: [
+        { attribute: "style/text-decoration", value: "underline" }
+    ]
+});
+const Strikethrough = /*@__PURE__*/Mark.define("Strikethrough", {
+    rank: 42,
+    shape: { element: "s" },
+    parseRules: [
+        { attribute: "style/text-decoration", value: "line-through" }
+    ]
+});
+const Superscript = /*@__PURE__*/Mark.define("Superscript", {
+    rank: 45,
+    shape: { element: "sup" }
+});
+const Subscript = /*@__PURE__*/Mark.define("Subscript", {
+    rank: 47,
+    shape: { element: "sub" }
+});
+const Link = /*@__PURE__*/Mark.Type.define("Link", {
+    rank: 20,
+    validate: "string",
+    inclusive: false,
+    shape: {
+        element: "a",
+        preferTarget: "a[href]",
+        attributes: href => ({ href }),
+        readElement: dom => dom.href
+    },
+});
+const Code = /*@__PURE__*/Mark.define("Code", {
+    rank: 80,
+    shape: { element: "code" }
+});
+const Color = /*@__PURE__*/Mark.Type.define("Color", {
+    rank: 30,
+    shape: { attribute: "style/color", value: 0 },
+    spanning: true,
+});
+const BackgroundColor = /*@__PURE__*/Mark.Type.define("BackgroundColor", {
+    rank: 35,
+    shape: { attribute: "style/background-color", value: 0 },
+    spanning: true,
+});
+const Doc = /*@__PURE__*/(() => Plot.defineDoc({
+    blockContent: G.Content
+}))();
+const InlineDoc = /*@__PURE__*/Plot.defineDoc({
+    inlineContent: true
+});
+
+export { Alignment, BackgroundColor, BlockCell, BlockHeaderCell, Blockquote, BulletList, CaptionedFigure, Cell, Code, CodeBlock, CodeBlockLanguage, ColSpan, Color, Direction, Doc, Emphasis, Figure, HeaderCell, Heading, HorizontalRule, Image, ImageAlt, ImageSize, InlineDoc, InlineListItem, LineBreak, Link, ListItem, OrderedList, Paragraph, RowSpan, Strikethrough, Strong, Subscript, Superscript, Table, TableRow, Underline };

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@nerd-bible/wordgard",
+  "version": "0.3.3",
+  "description": "Semantic rich text editor system",
+  "type": "module",
+  "main": "dist/index.js",
+  "exports": {
+    ".": "./dist/index.js",
+    "./doc": "./dist/doc.js",
+    "./types": "./dist/types.js",
+    "./schema": "./dist/schema.js",
+    "./table": "./dist/table.js",
+    "./state": "./dist/state.js",
+    "./editor": "./dist/editor.js",
+    "./command": "./dist/command.js",
+    "./history": "./dist/history.js",
+    "./collab": "./dist/collab.js",
+    "./phrases": "./dist/phrases.js"
+  },
+  "files": [
+    "/dist"
+  ],
+  "author": "Marijn Haverbeke <marijn@haverbeke.berlin>",
+  "license": "MIT",
+  "dependencies": {
+    "@marijn/find-cluster-break": "^1.0.2",
+    "crelt": "^1.0.6",
+    "style-mod": "^4.1.3"
+  },
+  "devDependencies": {
+    "@nerd-bible/config": "^0.2.2",
+    "@swc/wasm-typescript": "^1.15.3",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^24.10.2",
+    "acorn": "^8.16.0",
+    "acorn-walk": "^8.3.5",
+    "esmoduleserve": "^0.3.1",
+    "ist": "^1.1.7",
+    "mocha": "^11.7.6",
+    "rollup": "^4.60.1",
+    "rollup-plugin-dts": "^6.4.1",
+    "send": "^1.2.1",
+    "serve-static": "^1.15.0",
+    "typescript": "^6.0.3"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "repository": {
+    "url": "https://github.com/nerd-bible/wordgard"
+  }
+}