@owomark/core 0.1.6 → 0.1.8

package/dist/chunk-CJSBFWKS.js

@@ -0,0 +1,549 @@
+import {
+  expandDirtyRange,
+  expandWithContext
+} from "./chunk-WFPUIPWU.js";
+
+// src/model/selection/block-cache.ts
+var blockCacheMap = /* @__PURE__ */ new WeakMap();
+function getBlocks(root) {
+  let cached = blockCacheMap.get(root);
+  if (cached) {
+    return cached;
+  }
+  cached = Array.from(root.querySelectorAll("[data-owo-block]"));
+  blockCacheMap.set(root, cached);
+  return cached;
+}
+function invalidateBlockCache(root) {
+  blockCacheMap.delete(root);
+}
+function getOwnerBlock(root, node) {
+  if (node === root) {
+    return null;
+  }
+  if (node.nodeType === Node.ELEMENT_NODE) {
+    const el = node;
+    if (el.hasAttribute("data-owo-block")) {
+      return el;
+    }
+    return el.closest?.("[data-owo-block]");
+  }
+  return node.parentElement?.closest("[data-owo-block]") ?? null;
+}
+function getModelTextLength(root) {
+  const blocks = getBlocks(root);
+  if (blocks.length === 0) {
+    return 0;
+  }
+  let len = 0;
+  for (let index = 0; index < blocks.length; index += 1) {
+    if (index > 0) {
+      len += 1;
+    }
+    len += blocks[index].textContent?.length ?? 0;
+  }
+  return len;
+}
+
+// src/model/selection/linear-dom.ts
+function countTextWithinBlockBefore(block, target) {
+  const walker = block.ownerDocument.createTreeWalker(block, NodeFilter.SHOW_TEXT);
+  let count = 0;
+  while (walker.nextNode()) {
+    const textNode = walker.currentNode;
+    if (textNode === target) {
+      break;
+    }
+    const pos = textNode.compareDocumentPosition(target);
+    const isBeforeTarget = (pos & Node.DOCUMENT_POSITION_FOLLOWING) !== 0;
+    const isInsideTarget = (pos & Node.DOCUMENT_POSITION_CONTAINED_BY) !== 0;
+    if (isBeforeTarget && !isInsideTarget) {
+      count += textNode.textContent?.length ?? 0;
+    } else {
+      break;
+    }
+  }
+  return count;
+}
+function countTextBefore(root, target) {
+  const blocks = getBlocks(root);
+  const targetBlock = getOwnerBlock(root, target);
+  let count = 0;
+  for (let index = 0; index < blocks.length; index += 1) {
+    const block = blocks[index];
+    if (index > 0) {
+      count += 1;
+    }
+    if (block === targetBlock) {
+      count += countTextWithinBlockBefore(block, target);
+      return count;
+    }
+    const pos = block.compareDocumentPosition(target);
+    if ((pos & Node.DOCUMENT_POSITION_FOLLOWING) !== 0) {
+      count += block.textContent?.length ?? 0;
+    } else {
+      return count;
+    }
+  }
+  return count;
+}
+function countBlockStartOffset(root, targetBlock) {
+  const blocks = getBlocks(root);
+  let offset = 0;
+  for (const block of blocks) {
+    if (block === targetBlock) {
+      return offset;
+    }
+    offset += (block.textContent?.length ?? 0) + 1;
+  }
+  return offset;
+}
+function firstPositionInBlock(block) {
+  const walker = block.ownerDocument.createTreeWalker(block, NodeFilter.SHOW_TEXT);
+  if (walker.nextNode()) {
+    return { node: walker.currentNode, offset: 0 };
+  }
+  return { node: block, offset: 0 };
+}
+function lastPositionInBlock(block) {
+  const walker = block.ownerDocument.createTreeWalker(block, NodeFilter.SHOW_TEXT);
+  let lastText = null;
+  while (walker.nextNode()) {
+    lastText = walker.currentNode;
+  }
+  if (lastText) {
+    return { node: lastText, offset: lastText.textContent?.length ?? 0 };
+  }
+  return { node: block, offset: block.childNodes.length };
+}
+function nodeOffsetToLinear(root, node, offset) {
+  if (!root.contains(node)) {
+    return null;
+  }
+  if (node === root) {
+    const targetChild2 = root.childNodes[offset];
+    if (targetChild2) {
+      return countTextBefore(root, targetChild2);
+    }
+    return getModelTextLength(root);
+  }
+  if (node.nodeType === Node.TEXT_NODE) {
+    return countTextBefore(root, node) + offset;
+  }
+  const el = node;
+  const targetChild = el.childNodes[offset];
+  if (targetChild) {
+    return countTextBefore(root, targetChild);
+  }
+  const block = getOwnerBlock(root, node);
+  if (block) {
+    return countBlockStartOffset(root, block) + (node === block ? block.textContent?.length ?? 0 : countTextWithinBlockBefore(block, node) + (node.textContent?.length ?? 0));
+  }
+  return getModelTextLength(root);
+}
+function linearToNodeOffset(root, offset) {
+  const blocks = getBlocks(root);
+  if (blocks.length === 0) {
+    return { node: root, offset: 0 };
+  }
+  let pos = 0;
+  for (let index = 0; index < blocks.length; index += 1) {
+    const block = blocks[index];
+    if (index > 0) {
+      if (pos === offset) {
+        return firstPositionInBlock(block);
+      }
+      pos += 1;
+    }
+    const blockTextLen = block.textContent?.length ?? 0;
+    if (pos + blockTextLen >= offset) {
+      const inBlockOffset = offset - pos;
+      if (inBlockOffset === 0) {
+        return firstPositionInBlock(block);
+      }
+      const walker = block.ownerDocument.createTreeWalker(block, NodeFilter.SHOW_TEXT);
+      let blockPos = 0;
+      while (walker.nextNode()) {
+        const textNode = walker.currentNode;
+        const len = textNode.textContent?.length ?? 0;
+        if (blockPos + len >= inBlockOffset) {
+          return { node: textNode, offset: inBlockOffset - blockPos };
+        }
+        blockPos += len;
+      }
+      return lastPositionInBlock(block);
+    }
+    pos += blockTextLen;
+  }
+  return lastPositionInBlock(blocks[blocks.length - 1]);
+}
+
+// src/model/selection/dom-range.ts
+function domRangeToOffset(root, range) {
+  const anchor = nodeOffsetToLinear(root, range.startContainer, range.startOffset);
+  const focus = nodeOffsetToLinear(root, range.endContainer, range.endOffset);
+  if (anchor === null || focus === null) {
+    return null;
+  }
+  return { anchor, focus };
+}
+function offsetToDomRange(root, selection) {
+  const doc = root.ownerDocument;
+  const range = doc.createRange();
+  const textLen = getModelTextLength(root);
+  const clampedAnchor = Math.max(0, Math.min(selection.anchor, textLen));
+  const clampedFocus = Math.max(0, Math.min(selection.focus, textLen));
+  const start = linearToNodeOffset(root, Math.min(clampedAnchor, clampedFocus));
+  const end = linearToNodeOffset(root, Math.max(clampedAnchor, clampedFocus));
+  if (!start || !end) {
+    return null;
+  }
+  range.setStart(start.node, start.offset);
+  range.setEnd(end.node, end.offset);
+  return range;
+}
+
+// src/model/selection/index.ts
+function restoreSelection(root, selection) {
+  const textLen = getModelTextLength(root);
+  const clamped = {
+    anchor: Math.max(0, Math.min(selection.anchor, textLen)),
+    focus: Math.max(0, Math.min(selection.focus, textLen))
+  };
+  const range = offsetToDomRange(root, clamped);
+  if (!range) {
+    return;
+  }
+  const sel = root.ownerDocument.getSelection();
+  if (!sel) {
+    return;
+  }
+  sel.removeAllRanges();
+  if (clamped.anchor <= clamped.focus) {
+    sel.addRange(range);
+    return;
+  }
+  sel.addRange(range);
+  sel.collapseToEnd();
+  const focusPos = linearToNodeOffset(root, clamped.focus);
+  if (focusPos) {
+    sel.extend(focusPos.node, focusPos.offset);
+  }
+}
+function readSelection(root) {
+  const sel = root.ownerDocument.getSelection();
+  if (!sel || sel.rangeCount === 0) {
+    return null;
+  }
+  if (!root.contains(sel.anchorNode)) {
+    return null;
+  }
+  const anchor = nodeOffsetToLinear(root, sel.anchorNode, sel.anchorOffset);
+  const focus = nodeOffsetToLinear(root, sel.focusNode, sel.focusOffset);
+  if (anchor === null || focus === null) {
+    return null;
+  }
+  return { anchor, focus };
+}
+
+// src/render/blockquote-bars.ts
+var BQ_BAR_WIDTH = 3;
+var BQ_GAP = 12;
+var BQ_STEP = BQ_BAR_WIDTH + BQ_GAP;
+function buildBlockquoteBarsBoxShadow(depth) {
+  if (depth <= 1) return null;
+  const shadows = [];
+  for (let i = depth - 1; i >= 1; i--) {
+    const barEnd = i * BQ_STEP;
+    shadows.push(`inset ${barEnd}px 0 0 0 var(--owo-editor-bg, #ffffff)`);
+    shadows.push(`inset ${barEnd + BQ_BAR_WIDTH}px 0 0 0 var(--owo-editor-border-strong, #cbd5e1)`);
+  }
+  return shadows.join(", ");
+}
+
+// src/render/block-render.ts
+var TOKEN_CLASS_EXEMPTIONS = /* @__PURE__ */ new Set(["text"]);
+function applyBlockquoteBarsStyle(el, depth) {
+  const shadow = buildBlockquoteBarsBoxShadow(depth);
+  if (!shadow) return;
+  el.style.paddingLeft = `${depth * BQ_STEP}px`;
+  el.style.boxShadow = shadow;
+}
+var TOKEN_TO_CLASS = {
+  "text": "",
+  "strong-marker": "owo-syntax-marker",
+  "strong": "owo-syntax-strong",
+  "emphasis-marker": "owo-syntax-marker",
+  "emphasis": "owo-syntax-emphasis",
+  "custom-inline-marker": "owo-syntax-marker",
+  "custom-inline": "owo-syntax-custom-inline",
+  "code-marker": "owo-syntax-marker",
+  "code": "owo-syntax-inline-code",
+  "link-bracket": "owo-syntax-marker",
+  "link-text": "owo-syntax-link-text",
+  "link-url": "owo-syntax-link-url",
+  "reference-bracket": "owo-syntax-marker",
+  "reference-label": "owo-syntax-link-url",
+  "image-marker": "owo-syntax-marker",
+  "image-alt": "owo-syntax-link-text",
+  "image-url": "owo-syntax-link-url",
+  "heading-marker": "owo-syntax-heading-marker",
+  "list-marker": "owo-syntax-list-marker",
+  "task-marker": "owo-syntax-task-marker",
+  "task-marker-checked": "owo-syntax-task-marker-checked",
+  "table-separator": "owo-syntax-table-separator",
+  "blockquote-marker": "owo-syntax-blockquote-marker",
+  "fence-marker": "owo-syntax-fence",
+  "fence-lang": "owo-syntax-fence-lang",
+  "code-block-text": "owo-syntax-code-block",
+  "strikethrough-marker": "owo-syntax-marker",
+  "strikethrough": "owo-syntax-strikethrough",
+  "math-marker": "owo-syntax-marker",
+  "math-text": "owo-syntax-math",
+  "hr": "owo-syntax-hr",
+  "html": "owo-syntax-html"
+};
+var BLOCK_TYPE_TO_CLASS = {
+  "heading": "owo-block-heading",
+  "paragraph": "owo-block-paragraph",
+  "unordered-list": "owo-block-list",
+  "ordered-list": "owo-block-list",
+  "blockquote": "owo-block-blockquote",
+  "code-fence": "owo-block-code-fence",
+  "side-annotation": "owo-block-directive-container",
+  "side-note-definition": "owo-block-directive-container",
+  "directive-container": "owo-block-directive-container",
+  "custom-block": "owo-block-directive-container",
+  "thematic-break": "owo-block-hr",
+  "math-block": "owo-block-math",
+  "table": "owo-block-table"
+};
+function createBlockElement(doc, tokens, blockIndex, blockType, headingLevel, depth) {
+  const div = doc.createElement("div");
+  div.setAttribute("data-owo-block", String(blockIndex));
+  div.className = BLOCK_TYPE_TO_CLASS[blockType] || "owo-block-paragraph";
+  if (blockType === "heading" && headingLevel) {
+    div.setAttribute("data-owo-heading", String(headingLevel));
+  }
+  if (blockType === "blockquote" && depth && depth > 0) {
+    div.setAttribute("data-owo-depth", String(depth));
+    applyBlockquoteBarsStyle(div, depth);
+  }
+  renderTokensInto(doc, div, tokens);
+  return div;
+}
+function renderTokensInto(doc, container, tokens) {
+  for (const token of tokens) {
+    const cls = TOKEN_TO_CLASS[token.type];
+    const parts = token.text.split("\n");
+    for (let i = 0; i < parts.length; i++) {
+      if (i > 0) {
+        container.appendChild(doc.createTextNode("\n"));
+      }
+      const part = parts[i];
+      if (!part && i < parts.length - 1) continue;
+      const leaf = doc.createElement("span");
+      leaf.setAttribute("data-owo-leaf", "true");
+      leaf.textContent = part;
+      if (cls) {
+        const decorator = doc.createElement("span");
+        decorator.className = cls;
+        decorator.setAttribute("data-owo-token", token.type);
+        if (token.syntaxKey) {
+          decorator.setAttribute("data-owo-syntax-key", token.syntaxKey);
+        }
+        decorator.appendChild(leaf);
+        container.appendChild(decorator);
+      } else {
+        if (part) {
+          container.appendChild(leaf);
+        }
+      }
+    }
+  }
+  if (container.childNodes.length === 0) {
+    container.appendChild(doc.createElement("br"));
+  }
+}
+function renderDecoratorsInto(doc, container, decorators) {
+  for (const decorator of decorators) {
+    const cls = TOKEN_TO_CLASS[decorator.type];
+    const text = decorator.leaves.map((leaf) => leaf.text).join("");
+    const parts = text.split("\n");
+    for (let index = 0; index < parts.length; index += 1) {
+      if (index > 0) {
+        container.appendChild(doc.createTextNode("\n"));
+      }
+      const part = parts[index];
+      if (!part && index < parts.length - 1) {
+        continue;
+      }
+      const leaf = doc.createElement("span");
+      leaf.setAttribute("data-owo-leaf", "true");
+      leaf.textContent = part;
+      if (cls) {
+        const decoratorEl = doc.createElement("span");
+        decoratorEl.className = cls;
+        decoratorEl.setAttribute("data-owo-token", decorator.type);
+        if (decorator.syntaxKey) {
+          decoratorEl.setAttribute("data-owo-syntax-key", decorator.syntaxKey);
+        }
+        decoratorEl.appendChild(leaf);
+        container.appendChild(decoratorEl);
+      } else if (part) {
+        container.appendChild(leaf);
+      }
+    }
+  }
+  if (container.childNodes.length === 0) {
+    container.appendChild(doc.createElement("br"));
+  }
+}
+function createBlockElementFromDecorators(doc, decorators, blockIndex, blockType, headingLevel, depth) {
+  const div = doc.createElement("div");
+  div.setAttribute("data-owo-block", String(blockIndex));
+  div.className = BLOCK_TYPE_TO_CLASS[blockType] || "owo-block-paragraph";
+  if (blockType === "heading" && headingLevel) {
+    div.setAttribute("data-owo-heading", String(headingLevel));
+  }
+  if (blockType === "blockquote" && depth && depth > 0) {
+    div.setAttribute("data-owo-depth", String(depth));
+    applyBlockquoteBarsStyle(div, depth);
+  }
+  renderDecoratorsInto(doc, div, decorators);
+  return div;
+}
+function updateBlockElementFromDecorators(doc, existing, decorators, blockType, headingLevel, depth) {
+  const newClass = BLOCK_TYPE_TO_CLASS[blockType] || "owo-block-paragraph";
+  if (existing.className !== newClass) {
+    existing.className = newClass;
+  }
+  if (blockType === "heading" && headingLevel) {
+    existing.setAttribute("data-owo-heading", String(headingLevel));
+  } else {
+    existing.removeAttribute("data-owo-heading");
+  }
+  if (blockType === "blockquote" && depth && depth > 0) {
+    existing.setAttribute("data-owo-depth", String(depth));
+    applyBlockquoteBarsStyle(existing, depth);
+  } else {
+    existing.removeAttribute("data-owo-depth");
+    existing.style.paddingLeft = "";
+    existing.style.boxShadow = "";
+  }
+  existing.textContent = "";
+  renderDecoratorsInto(doc, existing, decorators);
+  return true;
+}
+function updateBlockElement(doc, existing, tokens, blockType, headingLevel, depth) {
+  const newClass = BLOCK_TYPE_TO_CLASS[blockType] || "owo-block-paragraph";
+  if (existing.className !== newClass) {
+    existing.className = newClass;
+  }
+  if (blockType === "heading" && headingLevel) {
+    existing.setAttribute("data-owo-heading", String(headingLevel));
+  } else {
+    existing.removeAttribute("data-owo-heading");
+  }
+  if (blockType === "blockquote" && depth && depth > 0) {
+    existing.setAttribute("data-owo-depth", String(depth));
+    applyBlockquoteBarsStyle(existing, depth);
+  } else {
+    existing.removeAttribute("data-owo-depth");
+    existing.style.paddingLeft = "";
+    existing.style.boxShadow = "";
+  }
+  existing.textContent = "";
+  renderTokensInto(doc, existing, tokens);
+  return true;
+}
+
+// src/render/dom-patch.ts
+function fullRender(root, doc) {
+  const ownerDoc = root.ownerDocument;
+  root.textContent = "";
+  let offset = 0;
+  for (let i = 0; i < doc.blocks.length; i++) {
+    const block = doc.blocks[i];
+    const el = createBlockElementFromDecorators(
+      ownerDoc,
+      block.decorators,
+      i,
+      block.type,
+      block.type === "heading" ? block.headingLevel : void 0,
+      block.depth
+    );
+    root.appendChild(el);
+    offset += block.raw.length + 1;
+  }
+  invalidateBlockCache(root);
+}
+function patchDirtyBlocks(root, doc, dirty) {
+  const ownerDoc = root.ownerDocument;
+  const blockElements = getBlockElements(root);
+  if (blockElements.length !== doc.blocks.length) {
+    fullRender(root, doc);
+    return;
+  }
+  for (let i = dirty.startBlock; i <= dirty.endBlock && i < doc.blocks.length; i++) {
+    const block = doc.blocks[i];
+    const existing = blockElements[i];
+    if (existing) {
+      updateBlockElementFromDecorators(
+        ownerDoc,
+        existing,
+        block.decorators,
+        block.type,
+        block.type === "heading" ? block.headingLevel : void 0,
+        block.depth
+      );
+    }
+  }
+}
+function detectAndRenderDirty(root, oldDoc, newDoc, fullFallback = false) {
+  const oldBlockCount = oldDoc.blocks.length;
+  const newBlockCount = newDoc.blocks.length;
+  if (oldBlockCount !== newBlockCount) {
+    fullRender(root, newDoc);
+    return;
+  }
+  let dirty = null;
+  for (let i = 0; i < newBlockCount; i++) {
+    if (newDoc.blocks[i].raw !== oldDoc.blocks[i].raw || newDoc.blocks[i].type !== oldDoc.blocks[i].type || newDoc.blocks[i].tokenizationContextKey !== oldDoc.blocks[i].tokenizationContextKey) {
+      dirty = expandDirtyRange(dirty, i, newBlockCount);
+    }
+  }
+  if (dirty) {
+    const expanded = expandWithContext(dirty, newBlockCount);
+    if (expanded) patchDirtyBlocks(root, newDoc, expanded);
+  } else if (fullFallback) {
+    fullRender(root, newDoc);
+  }
+}
+function getBlockElements(root) {
+  const elements = [];
+  for (const child of root.children) {
+    if (child instanceof HTMLElement && child.hasAttribute("data-owo-block")) {
+      elements.push(child);
+    }
+  }
+  return elements;
+}
+
+export {
+  invalidateBlockCache,
+  domRangeToOffset,
+  offsetToDomRange,
+  restoreSelection,
+  readSelection,
+  BQ_STEP,
+  buildBlockquoteBarsBoxShadow,
+  TOKEN_CLASS_EXEMPTIONS,
+  TOKEN_TO_CLASS,
+  BLOCK_TYPE_TO_CLASS,
+  createBlockElement,
+  updateBlockElement,
+  fullRender,
+  patchDirtyBlocks,
+  detectAndRenderDirty
+};

package/dist/chunk-OOH46GIF.js

@@ -0,0 +1,95 @@
+// src/semantic/shared/registry.ts
+function deepFreezeValue(value) {
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      deepFreezeValue(item);
+    }
+    return Object.freeze(value);
+  }
+  if (value && typeof value === "object") {
+    for (const nestedValue of Object.values(value)) {
+      deepFreezeValue(nestedValue);
+    }
+    return Object.freeze(value);
+  }
+  return value;
+}
+function freezeDescriptor(descriptor) {
+  return deepFreezeValue(descriptor);
+}
+function createDescriptorRegistry(descriptors, familyName) {
+  const frozen = descriptors.map((descriptor) => freezeDescriptor({ ...descriptor }));
+  const index = /* @__PURE__ */ new Map();
+  for (const descriptor of frozen) {
+    if (index.has(descriptor.key)) {
+      throw new Error(`[owomark/semantic] duplicate ${familyName} descriptor key "${descriptor.key}"`);
+    }
+    index.set(descriptor.key, descriptor);
+  }
+  return {
+    list() {
+      return frozen;
+    },
+    get(key) {
+      return index.get(key);
+    }
+  };
+}
+function requireDescriptor(registry, key, familyName) {
+  const descriptor = registry.get(key);
+  if (!descriptor) {
+    throw new Error(`[owomark/semantic] unknown ${familyName} descriptor "${key}"`);
+  }
+  return descriptor;
+}
+
+// src/semantic/shared/validation.ts
+function assertSpecIds(specIds, family, key) {
+  if (specIds.length === 0) {
+    throw new Error(`[owomark/semantic] ${family} descriptor "${key}" must declare at least one specId`);
+  }
+}
+function validateSyntaxDescriptors(descriptors) {
+  for (const descriptor of descriptors) {
+    assertSpecIds(descriptor.specIds, "syntax", descriptor.key);
+  }
+}
+function validateComponentDescriptors(descriptors) {
+  const directiveNames = /* @__PURE__ */ new Set();
+  for (const descriptor of descriptors) {
+    assertSpecIds(descriptor.specIds, "component", descriptor.key);
+    if (directiveNames.has(descriptor.directiveName)) {
+      throw new Error(`[owomark/semantic] duplicate component directive "${descriptor.directiveName}"`);
+    }
+    directiveNames.add(descriptor.directiveName);
+  }
+}
+function validateRuntimeDescriptors(descriptors) {
+  const blockTypes = /* @__PURE__ */ new Set();
+  for (const descriptor of descriptors) {
+    assertSpecIds(descriptor.specIds, "runtime", descriptor.key);
+    if (blockTypes.has(descriptor.blockType)) {
+      throw new Error(`[owomark/semantic] duplicate runtime block type "${descriptor.blockType}"`);
+    }
+    blockTypes.add(descriptor.blockType);
+  }
+}
+function validateEditorEntryDescriptors(descriptors) {
+  const commandIds = /* @__PURE__ */ new Set();
+  for (const descriptor of descriptors) {
+    assertSpecIds(descriptor.specIds, "editor", descriptor.key);
+    if (commandIds.has(descriptor.commandId)) {
+      throw new Error(`[owomark/semantic] duplicate editor command id "${descriptor.commandId}"`);
+    }
+    commandIds.add(descriptor.commandId);
+  }
+}
+
+export {
+  createDescriptorRegistry,
+  requireDescriptor,
+  validateSyntaxDescriptors,
+  validateComponentDescriptors,
+  validateRuntimeDescriptors,
+  validateEditorEntryDescriptors
+};