@nuucognition/ncm-ui 0.1.1-beta.1 → 0.1.1-beta.3

package/dist/lib/defaults.js

@@ -1,9 +1,9 @@
 "use client";
-import { createContext, useState, createElement, useMemo, useContext, useCallback, useEffect, useRef, Component, useId } from 'react';
+import { createContext, useMemo, useState, createElement, useContext, useCallback, useEffect, useRef, Component, useId } from 'react';
 import { clsx } from 'clsx';
 import { twMerge } from 'tailwind-merge';
 import { jsxs, jsx, Fragment } from 'react/jsx-runtime';
-import { serializeInlineContent, isTypedNestedList } from '@nuucognition/ncm';
+import { serializeInlineContent, isTypedNestedList, parseNcm } from '@nuucognition/ncm';
 import { extractExtension, embedTypeFromExtension } from '@nuucognition/mesh-core';
 
 // src/lib/defaults.ts
@@ -71,6 +71,52 @@ function tryParseInlineRef(input) {
   }
   return { token: { type: "inline_ref", kind: "footnote", content: inner.trim() }, length };
 }
+function runLength(input, index, char) {
+  let end = index;
+  while (end < input.length && input[end] === char) end++;
+  return end - index;
+}
+function tryParseEmphasis(input) {
+  const char = input[0];
+  if (char !== "*" && char !== "_") return null;
+  const open = Math.min(3, runLength(input, 0, char));
+  const need = open;
+  let i = open;
+  while (i < input.length) {
+    const ch = input[i];
+    if (ch === "`") {
+      const close = input.indexOf("`", i + 1);
+      if (close === -1) break;
+      i = close + 1;
+      continue;
+    }
+    if (ch !== char) {
+      i++;
+      continue;
+    }
+    const run = runLength(input, i, char);
+    const closes = need === 1 ? run % 2 === 1 : run >= need;
+    if (!closes) {
+      i += run;
+      continue;
+    }
+    const extra = run - need;
+    const inner = input.slice(open, i + extra);
+    if (inner.length === 0) return null;
+    const length = i + run;
+    const children = parseInline(inner);
+    let token;
+    if (need === 3) {
+      token = { type: "bold", children: [{ type: "italic", children }] };
+    } else if (need === 2) {
+      token = { type: "bold", children };
+    } else {
+      token = { type: "italic", children };
+    }
+    return { token, length };
+  }
+  return null;
+}
 function parseInline(content) {
   if (!content) return [];
   const tokens = [];
@@ -142,17 +188,11 @@ function parseInline(content) {
       remaining = remaining.slice(linkMatch[0].length);
       continue;
     }
-    const boldMatch = remaining.match(/^\*\*(.+?)\*\*|^__(.+?)__/);
-    if (boldMatch) {
-      const innerContent = boldMatch[1] ?? boldMatch[2];
-      if (innerContent !== void 0) {
-        tokens.push({
-          type: "bold",
-          children: parseInline(innerContent)
-        });
-        remaining = remaining.slice(boldMatch[0].length);
-        continue;
-      }
+    const emphasis = tryParseEmphasis(remaining);
+    if (emphasis) {
+      tokens.push(emphasis.token);
+      remaining = remaining.slice(emphasis.length);
+      continue;
     }
     const strikeMatch = remaining.match(/^~~(.+?)~~/);
     if (strikeMatch && strikeMatch[1] !== void 0) {
@@ -163,18 +203,6 @@ function parseInline(content) {
       remaining = remaining.slice(strikeMatch[0].length);
       continue;
     }
-    const italicMatch = remaining.match(/^\*([^*]+)\*|^_([^_]+)_/);
-    if (italicMatch) {
-      const innerContent = italicMatch[1] ?? italicMatch[2];
-      if (innerContent !== void 0) {
-        tokens.push({
-          type: "italic",
-          children: parseInline(innerContent)
-        });
-        remaining = remaining.slice(italicMatch[0].length);
-        continue;
-      }
-    }
     const nextSpecial = findNextSpecialChar(remaining);
     if (nextSpecial > 0) {
       tokens.push({ type: "text", content: remaining.slice(0, nextSpecial) });
@@ -209,17 +237,30 @@ function mergeAdjacentText(tokens) {
   }
   return result;
 }
-var ReferenceBasesContext = createContext(null);
+function normalizeReferenceContent(content) {
+  return content.replace(/\s+/g, " ").trim().toLowerCase();
+}
+var ReferenceNumberingContext = createContext(null);
 var BlockReferenceScopeContext = createContext(null);
-function BlockReferenceScope({ blockId, children }) {
-  const bases = useContext(ReferenceBasesContext);
-  const base = (blockId ? bases?.get(blockId) : void 0) ?? { ref: 0, footnote: 0 };
+function BlockReferenceScope({ children }) {
+  const numbering = useContext(ReferenceNumberingContext);
+  const local = useRef({ ref: /* @__PURE__ */ new Map(), footnote: /* @__PURE__ */ new Map() });
   const counter = useRef({ ref: 0, footnote: 0 });
-  counter.current = { ref: 0, footnote: 0 };
   const value = {
+    numberFor(kind, content) {
+      const key = normalizeReferenceContent(content);
+      const fromDocument = numbering?.[kind].get(key);
+      if (fromDocument !== void 0) return fromDocument;
+      const map = local.current[kind];
+      const existing = map.get(key);
+      if (existing !== void 0) return existing;
+      counter.current[kind] += 1;
+      map.set(key, counter.current[kind]);
+      return counter.current[kind];
+    },
     next(kind) {
       counter.current[kind] += 1;
-      return base[kind] + counter.current[kind];
+      return counter.current[kind];
     }
   };
   return /* @__PURE__ */ jsx(BlockReferenceScopeContext.Provider, { value, children });
@@ -227,7 +268,7 @@ function BlockReferenceScope({ blockId, children }) {
 function useBlockReferenceScope() {
   return useContext(BlockReferenceScopeContext);
 }
-var INERT_SCOPE = { next: () => 0 };
+var INERT_SCOPE = { numberFor: () => 0, next: () => 0 };
 function InertReferenceScope({ children }) {
   return /* @__PURE__ */ jsx(BlockReferenceScopeContext.Provider, { value: INERT_SCOPE, children });
 }
@@ -751,7 +792,7 @@ function TokenRenderer({ token, disableBionic, disableBeeline }) {
       );
     }
     case "inline_ref": {
-      const number = refScope?.next(token.kind) ?? 0;
+      const number = refScope?.numberFor(token.kind, token.content) ?? 0;
       return /* @__PURE__ */ jsx(ReferenceMarker, { kind: token.kind, number, children: token.content ? /* @__PURE__ */ jsx(InertReferenceScope, { children: /* @__PURE__ */ jsx(InlineContent, { content: token.content, disableBionic: true, disableBeeline: true }) }) : null });
     }
     default:
@@ -817,8 +858,32 @@ function renderReadingText(content, opts) {
   if (cursor < content.length) pieces.push(content.slice(cursor));
   return /* @__PURE__ */ jsx(Fragment, { children: pieces });
 }
+function quoteBlocks(block) {
+  try {
+    const doc = parseNcm(block.content, {
+      preset: "ncm-full",
+      allowMissingFrontmatter: true,
+      // Attribution off, as the NUU Editor's bridge keeps it: the promoter's
+      // trigger is any last quote line starting with `-`, so a nested quote
+      // ending in a list item would lose that item to a `— Author` line.
+      blockOptions: { extensions: { attribution: false } }
+    });
+    const blocks = doc.blocks ?? [];
+    if (blocks.length === 0 || blocks.some((child) => child.type === "frontmatter")) {
+      return null;
+    }
+    return blocks.map((child, index) => ({ ...child, id: `${block.id}.${index + 1}`, stableId: void 0 }));
+  } catch {
+    return null;
+  }
+}
+function QuotedLines({ content }) {
+  const lines = content.split("\n");
+  return /* @__PURE__ */ jsx(Fragment, { children: lines.map((line, index) => /* @__PURE__ */ jsx("p", { children: line.trim().length > 0 ? /* @__PURE__ */ jsx(InlineContent, { content: line }) : /* @__PURE__ */ jsx("span", { "aria-hidden": "true", children: "\xA0" }) }, index)) });
+}
 function BlockquoteBlock({ block, className }) {
-  const lines = block.content.split("\n");
+  const multiline = block.content.includes("\n");
+  const blocks = useMemo(() => multiline ? quoteBlocks(block) : null, [block, multiline]);
   return /* @__PURE__ */ jsx(
     "blockquote",
     {
@@ -828,7 +893,9 @@ function BlockquoteBlock({ block, className }) {
       "data-block-id": block.id,
       "data-ncm-blockquote": "",
       className,
-      children: lines.length <= 1 ? /* @__PURE__ */ jsx(InlineContent, { content: block.content }) : lines.map((line, index) => /* @__PURE__ */ jsx("p", { children: line.trim().length > 0 ? /* @__PURE__ */ jsx(InlineContent, { content: line }) : /* @__PURE__ */ jsx("span", { "aria-hidden": "true", children: "\xA0" }) }, index))
+      children: !multiline ? /* @__PURE__ */ jsx(InlineContent, { content: block.content }) : blocks === null ? /* @__PURE__ */ jsx(QuotedLines, { content: block.content }) : blocks.map(
+        (child) => child.type === "paragraph" ? /* @__PURE__ */ jsx(QuotedLines, { content: child.content ?? "" }, blockKey(child)) : /* @__PURE__ */ jsx(NcmBlock, { block: child }, blockKey(child))
+      )
     }
   );
 }
@@ -1047,6 +1114,48 @@ function DefinitionBlock({ block, className }) {
     }
   );
 }
+function fileNameOf(src) {
+  let path = src.split(/[?#]/)[0] ?? "";
+  if (/^https?:\/\//i.test(src)) {
+    try {
+      path = new URL(src).pathname;
+    } catch {
+      return "";
+    }
+  }
+  return path.slice(path.lastIndexOf("/") + 1);
+}
+function isExtensionless(src) {
+  const name = fileNameOf(src);
+  const dot = name.lastIndexOf(".");
+  return dot <= 0 || dot === name.length - 1;
+}
+function EmbedPictureOrLink({
+  src,
+  alt,
+  title,
+  imgClassName,
+  linkAttrs
+}) {
+  const [failedSrc, setFailedSrc] = useState(null);
+  useEffect(() => {
+    setFailedSrc(null);
+  }, [src]);
+  if (failedSrc === src) {
+    return /* @__PURE__ */ jsx("a", { href: src, title, ...linkAttrs, children: alt || src });
+  }
+  return /* @__PURE__ */ jsx(
+    "img",
+    {
+      "data-ncm-embed-picture": "",
+      src,
+      alt,
+      title,
+      className: imgClassName,
+      onError: () => setFailedSrc(src)
+    }
+  );
+}
 function toEmbeddingConfigType(embedType) {
   switch (embedType) {
     case "image":
@@ -1075,6 +1184,9 @@ function EmbedBlock({ block, className }) {
   if (block.embedType === "image") {
     return /* @__PURE__ */ jsx("figure", { ...dataAttrs(block), className: cn(config.embeddings?.imageClassName, className), children: /* @__PURE__ */ jsx("img", { src: resolvedUrl, alt: block.alt, title: block.title ?? void 0 }) });
   }
+  if (block.embedType === "file" && isExtensionless(block.src)) {
+    return /* @__PURE__ */ jsx("figure", { ...dataAttrs(block), className: cn(config.embeddings?.imageClassName, className), children: /* @__PURE__ */ jsx(EmbedPictureOrLink, { src: resolvedUrl, alt: block.alt, title: block.title ?? void 0 }) });
+  }
   return /* @__PURE__ */ jsx("figure", { ...dataAttrs(block), className, children: /* @__PURE__ */ jsx("a", { href: resolvedUrl, title: block.title ?? void 0, children: block.alt || block.src }) });
 }
 var embedFrameStyle = {
@@ -1251,7 +1363,19 @@ function FigureBlock({ block, className }) {
       "data-ncm-figure": "",
       className: cn("space-y-2", className),
       children: [
-        embed.embedType === "image" ? /* @__PURE__ */ jsx("img", { src: embed.src, alt: embed.alt, title: embed.title ?? void 0 }) : /* @__PURE__ */ jsx(
+        embed.embedType === "image" ? /* @__PURE__ */ jsx("img", { src: embed.src, alt: embed.alt, title: embed.title ?? void 0 }) : embed.embedType === "file" && isExtensionless(embed.src) ? (
+          // Same rule as the standalone embed block: an image spelling with an
+          // extension-less destination is a picture until it fails to load.
+          /* @__PURE__ */ jsx(
+            EmbedPictureOrLink,
+            {
+              src: embed.src,
+              alt: embed.alt,
+              title: embed.title ?? void 0,
+              linkAttrs: { "data-ncm-embed-type": embed.embedType }
+            }
+          )
+        ) : /* @__PURE__ */ jsx(
           "a",
           {
             href: embed.src,

package/dist/references-BM-lvGrq.d.ts

@@ -0,0 +1,99 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { Block } from '@nuucognition/ncm';
+
+/**
+ * Numbering for inline references (`^[ref: ...]` / `^[footnote: ...]`).
+ *
+ * The two kinds are counted **independently**: refs produce `[1] [2] …` and
+ * footnotes produce `¹ ² …`.
+ *
+ * Numbers are assigned by a pure pre-pass over the `blocks` array and looked up
+ * by **token content**, never by render order. That makes the marker number a
+ * function of the document alone: it is stable under React re-renders,
+ * StrictMode double rendering, virtualised or out-of-order block rendering,
+ * and it gives every citation of the same source the same number.
+ *
+ * Refs additionally honour the document's own bibliography. When a paragraph
+ * reads `[16] Google Gemini Team. Gemini: …` and a `^[ref: Google Gemini
+ * Team. Gemini: …]` token carries that entry, the marker shows `[16]` — the
+ * number the source document uses — so the inline citation, the reference
+ * list, and the original paper all agree. Refs with no bibliography match are
+ * numbered sequentially in first-appearance order, continuing after the
+ * highest bibliography number so the two ranges never collide.
+ *
+ * Footnotes are numbered sequentially in first-appearance order (identical
+ * footnote text shares a number).
+ */
+type ReferenceKind = "ref" | "footnote";
+interface ReferenceCounts {
+    ref: number;
+    footnote: number;
+}
+/** Document-wide numbering: normalised token content → marker number. */
+interface ReferenceNumbering {
+    ref: Map<string, number>;
+    footnote: Map<string, number>;
+}
+/** Collapse whitespace and case so a token and its bibliography entry compare equal. */
+declare function normalizeReferenceContent(content: string): string;
+/**
+ * Map every `[n] entry` paragraph in the document to its number. The first
+ * paragraph carrying a given entry text wins.
+ */
+declare function collectBibliography(blocks: readonly Block[]): Map<string, number>;
+/**
+ * Compute the document-wide numbering (see the module comment for the rules).
+ */
+declare function computeReferenceNumbering(blocks: readonly Block[]): ReferenceNumbering;
+/**
+ * Per-block count of inline references, as the *previous* numbering scheme
+ * exposed it. Kept for API compatibility; the marker numbers no longer derive
+ * from these offsets.
+ */
+declare function computeReferenceBases(blocks: readonly Block[]): Map<string, ReferenceCounts>;
+interface BlockReferenceScopeValue {
+    /**
+     * The marker number for a token with this `kind` and `content`. Pure with
+     * respect to the document: the same content always gets the same number.
+     */
+    numberFor(kind: ReferenceKind, content: string): number;
+    /**
+     * Allocate the next number for `kind` in render order. Legacy API — prefer
+     * `numberFor`, which is stable under re-renders.
+     */
+    next(kind: ReferenceKind): number;
+}
+interface NcmReferencesProviderProps {
+    blocks: readonly Block[];
+    children: ReactNode;
+}
+/** Document-root provider — runs the numbering pre-pass over `blocks`. */
+declare function NcmReferencesProvider({ blocks, children }: NcmReferencesProviderProps): react.JSX.Element;
+interface BlockReferenceScopeProps {
+    /** Block id. Accepted for API compatibility; numbering is document-wide. */
+    blockId?: string;
+    children: ReactNode;
+}
+/**
+ * Reference scope for one block (or one standalone `InlineContent` fragment).
+ *
+ * Inside an `NcmDocument` it resolves numbers from the document pre-pass.
+ * Standalone — no `NcmReferencesProvider` above it — it numbers the fragment's
+ * own tokens by content in first-request order, which is still idempotent
+ * under StrictMode double rendering because a repeated request for the same
+ * content returns the same number.
+ */
+declare function BlockReferenceScope({ children }: BlockReferenceScopeProps): react.JSX.Element;
+/** Read the active per-block reference scope, if any. */
+declare function useBlockReferenceScope(): BlockReferenceScopeValue | null;
+/**
+ * Wrap a subtree so any inline references inside it do NOT take document
+ * numbers — used for a reference's own popover content, which the numbering
+ * pre-pass deliberately does not descend into.
+ */
+declare function InertReferenceScope({ children }: {
+    children: ReactNode;
+}): react.JSX.Element;
+
+export { BlockReferenceScope as B, InertReferenceScope as I, NcmReferencesProvider as N, type ReferenceCounts as R, type BlockReferenceScopeProps as a, type BlockReferenceScopeValue as b, type NcmReferencesProviderProps as c, type ReferenceKind as d, type ReferenceNumbering as e, collectBibliography as f, computeReferenceBases as g, computeReferenceNumbering as h, normalizeReferenceContent as n, useBlockReferenceScope as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuucognition/ncm-ui",
-  "version": "0.1.1-beta.1",
+  "version": "0.1.1-beta.3",
   "description": "React renderers for NUU Cognition Markdown (NCM) blocks — a component library that renders parsed NCM Blocks to accessible, themeable markup.",
   "type": "module",
   "license": "MIT",

package/dist/references-BYW5pnj_.d.ts

@@ -1,63 +0,0 @@
-import * as react from 'react';
-import { ReactNode } from 'react';
-import { Block } from '@nuucognition/ncm';
-
-/**
- * Document-order numbering for inline references (`^[ref: ...]` /
- * `^[footnote: ...]`).
- *
- * The two kinds are counted **independently**: refs produce `[1] [2] …` and
- * footnotes produce `¹ ² …`, each with its own running counter across the
- * whole document.
- *
- * Numbering is computed from the `blocks` array — a pure pre-pass that does not
- * depend on React render order — so markers stay stable even if a host
- * virtualises blocks or renders them out of order. The pre-pass yields, per
- * block, the count of each kind in all *preceding* blocks (the "base"); within
- * a block, a `BlockReferenceScope` hands out sequential numbers in render
- * order. Only the within-block step relies on the block's inline content
- * rendering as a synchronous subtree (it always does).
- */
-type ReferenceKind = "ref" | "footnote";
-interface ReferenceCounts {
-    ref: number;
-    footnote: number;
-}
-/**
- * Map each block id to the number of refs/footnotes that precede it in
- * document order — the starting offset for that block's own markers.
- */
-declare function computeReferenceBases(blocks: readonly Block[]): Map<string, ReferenceCounts>;
-interface BlockReferenceScopeValue {
-    /** Allocate the next document-order number for `kind` within this block. */
-    next(kind: ReferenceKind): number;
-}
-interface NcmReferencesProviderProps {
-    blocks: readonly Block[];
-    children: ReactNode;
-}
-/** Document-root provider — runs the numbering pre-pass over `blocks`. */
-declare function NcmReferencesProvider({ blocks, children }: NcmReferencesProviderProps): react.JSX.Element;
-interface BlockReferenceScopeProps {
-    /** Block id; resolves the base offset from the document pre-pass. */
-    blockId?: string;
-    children: ReactNode;
-}
-/**
- * Per-block numbering scope. Seeds a fresh counter from the block's base offset
- * on every render and hands out sequential numbers as markers render. Resetting
- * each render keeps numbering idempotent under React re-renders / StrictMode.
- */
-declare function BlockReferenceScope({ blockId, children }: BlockReferenceScopeProps): react.JSX.Element;
-/** Read the active per-block reference scope, if any. */
-declare function useBlockReferenceScope(): BlockReferenceScopeValue | null;
-/**
- * Wrap a subtree so any inline references inside it do NOT allocate
- * document-order numbers — used for a reference's own popover content, which
- * the numbering pre-pass deliberately does not descend into.
- */
-declare function InertReferenceScope({ children }: {
-    children: ReactNode;
-}): react.JSX.Element;
-
-export { BlockReferenceScope as B, InertReferenceScope as I, NcmReferencesProvider as N, type ReferenceCounts as R, type BlockReferenceScopeProps as a, type BlockReferenceScopeValue as b, type NcmReferencesProviderProps as c, type ReferenceKind as d, computeReferenceBases as e, useBlockReferenceScope as u };