@nuucognition/ncm-ui 0.1.0-dev.1

package/dist/context/index.d.ts

@@ -0,0 +1,7 @@
+export { C as CodeConfig, E as EmbeddingsConfig, I as InlineConfig, N as NcmConfig, a as NcmProvider, b as NcmProviderProps, u as useNcmConfig } from '../use-ncm-config-D0doMYTH.js';
+export { B as BlockReferenceScope, a as BlockReferenceScopeProps, b as BlockReferenceScopeValue, I as InertReferenceScope, N as NcmReferencesProvider, c as NcmReferencesProviderProps, R as ReferenceCounts, d as ReferenceKind, e as computeReferenceBases, u as useBlockReferenceScope } from '../references-Bs5wJybr.js';
+import 'react/jsx-runtime';
+import 'react';
+import '@nuucognition/mesh-core';
+import '@nuucognition/ncm';
+import '../renderers-C5f41FCy.js';

package/dist/context/index.js

@@ -0,0 +1,284 @@
+"use client";
+import { createContext, useContext, useMemo, useRef } from 'react';
+import { jsx } from 'react/jsx-runtime';
+import { isTypedNestedList } from '@nuucognition/ncm';
+
+// src/context/ncm-context.tsx
+var NcmContext = createContext(null);
+function useNcmConfig() {
+  return useContext(NcmContext) ?? {};
+}
+function NcmProvider({ config, children }) {
+  const value = useMemo(() => config ?? {}, [config]);
+  return /* @__PURE__ */ jsx(NcmContext.Provider, { value, children });
+}
+
+// src/inline/parser.ts
+function splitOnce(input, delimiter) {
+  const idx = input.indexOf(delimiter);
+  if (idx === -1) {
+    return [input, null];
+  }
+  return [input.slice(0, idx), input.slice(idx + delimiter.length)];
+}
+function parseWikiTarget(rawInside) {
+  const inside = rawInside.trim();
+  const [targetPlusAnchor, displayRaw] = splitOnce(inside, "|");
+  const [targetRaw, anchorRaw] = splitOnce(targetPlusAnchor, "#");
+  const target = targetRaw.trim();
+  const display = displayRaw !== null ? displayRaw.trim() || null : null;
+  const anchor = anchorRaw !== null ? anchorRaw.trim() || null : null;
+  return { target, display, anchor };
+}
+var INLINE_REF_KIND_RE = /^\s*(ref|footnote)\s*:\s*([\s\S]*)$/i;
+function tryParseInlineRef(input) {
+  let depth = 1;
+  let i = 2;
+  for (; i < input.length; i++) {
+    const ch = input[i];
+    if (ch === "[") {
+      depth++;
+    } else if (ch === "]") {
+      depth--;
+      if (depth === 0) break;
+    }
+  }
+  if (depth !== 0) return null;
+  const inner = input.slice(2, i);
+  const length = i + 1;
+  const match = INLINE_REF_KIND_RE.exec(inner);
+  if (match && match[1]) {
+    const kind = match[1].toLowerCase() === "ref" ? "ref" : "footnote";
+    return { token: { type: "inline_ref", kind, content: (match[2] ?? "").trim() }, length };
+  }
+  return { token: { type: "inline_ref", kind: "footnote", content: inner.trim() }, length };
+}
+function parseInline(content) {
+  if (!content) return [];
+  const tokens = [];
+  let remaining = content;
+  while (remaining.length > 0) {
+    const codeMatch = remaining.match(/^`([^`]+)`/);
+    if (codeMatch && codeMatch[1] !== void 0) {
+      tokens.push({ type: "code", content: codeMatch[1] });
+      remaining = remaining.slice(codeMatch[0].length);
+      continue;
+    }
+    const latexMatch = remaining.match(/^\$(?!\s)([^$\n]+?)(?<!\s)\$/);
+    if (latexMatch && latexMatch[1] !== void 0) {
+      tokens.push({ type: "latex", content: latexMatch[1] });
+      remaining = remaining.slice(latexMatch[0].length);
+      continue;
+    }
+    if (remaining.startsWith("^[")) {
+      const inlineRef = tryParseInlineRef(remaining);
+      if (inlineRef) {
+        tokens.push(inlineRef.token);
+        remaining = remaining.slice(inlineRef.length);
+        continue;
+      }
+    }
+    const wikiEmbedMatch = remaining.match(/^!\[\[([^\]]+)\]\]/);
+    if (wikiEmbedMatch && wikiEmbedMatch[1] !== void 0) {
+      const parsed = parseWikiTarget(wikiEmbedMatch[1]);
+      tokens.push({
+        type: "wiki_embed",
+        target: parsed.target,
+        display: parsed.display,
+        anchor: parsed.anchor
+      });
+      remaining = remaining.slice(wikiEmbedMatch[0].length);
+      continue;
+    }
+    const wikiLinkMatch = remaining.match(/^\[\[([^\]]+)\]\]/);
+    if (wikiLinkMatch && wikiLinkMatch[1] !== void 0) {
+      const parsed = parseWikiTarget(wikiLinkMatch[1]);
+      tokens.push({
+        type: "wiki_link",
+        target: parsed.target,
+        display: parsed.display,
+        anchor: parsed.anchor
+      });
+      remaining = remaining.slice(wikiLinkMatch[0].length);
+      continue;
+    }
+    const imageMatch = remaining.match(/^!\[([^\]]*)\]\(([^)\s]+)(?:\s+"([^"]+)")?\)/);
+    if (imageMatch && imageMatch[1] !== void 0 && imageMatch[2] !== void 0) {
+      tokens.push({
+        type: "image",
+        alt: imageMatch[1],
+        src: imageMatch[2],
+        title: imageMatch[3]
+      });
+      remaining = remaining.slice(imageMatch[0].length);
+      continue;
+    }
+    const linkMatch = remaining.match(/^\[([^\]]+)\]\(([^)\s]+)(?:\s+"([^"]+)")?\)/);
+    if (linkMatch && linkMatch[1] !== void 0 && linkMatch[2] !== void 0) {
+      tokens.push({
+        type: "link",
+        href: linkMatch[2],
+        title: linkMatch[3],
+        children: parseInline(linkMatch[1])
+      });
+      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 strikeMatch = remaining.match(/^~~(.+?)~~/);
+    if (strikeMatch && strikeMatch[1] !== void 0) {
+      tokens.push({
+        type: "strikethrough",
+        children: parseInline(strikeMatch[1])
+      });
+      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) });
+      remaining = remaining.slice(nextSpecial);
+    } else {
+      tokens.push({ type: "text", content: remaining });
+      remaining = "";
+    }
+  }
+  return mergeAdjacentText(tokens);
+}
+function findNextSpecialChar(content) {
+  const specialChars = ["`", "$", "!", "[", "*", "_", "~", "^"];
+  let minIndex = -1;
+  for (const char of specialChars) {
+    const index = content.indexOf(char);
+    if (index > 0 && (minIndex === -1 || index < minIndex)) {
+      minIndex = index;
+    }
+  }
+  return minIndex;
+}
+function mergeAdjacentText(tokens) {
+  const result = [];
+  for (const token of tokens) {
+    const last = result[result.length - 1];
+    if (token.type === "text" && last?.type === "text") {
+      last.content += token.content;
+    } else {
+      result.push(token);
+    }
+  }
+  return result;
+}
+function collectInlineStrings(block) {
+  switch (block.type) {
+    case "paragraph":
+    case "header":
+    case "blockquote":
+      return [block.content ?? ""];
+    case "list_ordered":
+    case "list_unordered":
+      return collectListStrings(block.items ?? []);
+    case "table": {
+      const t = block;
+      return [...t.headers ?? [], ...(t.rows ?? []).flat()];
+    }
+    case "embedding": {
+      const caption = block.caption;
+      return caption ? [caption] : [];
+    }
+    default:
+      return [];
+  }
+}
+function collectListStrings(items) {
+  const out = [];
+  for (const item of items) {
+    if (typeof item === "string") {
+      out.push(item);
+    } else if (isTypedNestedList(item)) {
+      out.push(...collectListStrings(item.items));
+    } else if (Array.isArray(item) && item.length > 0) {
+      const [first, ...rest] = item;
+      if (typeof first === "string") out.push(first);
+      out.push(...collectListStrings(rest));
+    }
+  }
+  return out;
+}
+function countInlineRefs(tokens, acc) {
+  for (const token of tokens) {
+    if (token.type === "inline_ref") {
+      acc[token.kind] += 1;
+    } else if ("children" in token) {
+      countInlineRefs(token.children, acc);
+    }
+  }
+}
+function countBlock(block) {
+  const acc = { ref: 0, footnote: 0 };
+  for (const str of collectInlineStrings(block)) {
+    if (str) countInlineRefs(parseInline(str), acc);
+  }
+  return acc;
+}
+function computeReferenceBases(blocks) {
+  const bases = /* @__PURE__ */ new Map();
+  const acc = { ref: 0, footnote: 0 };
+  for (const block of blocks) {
+    bases.set(block.id, { ...acc });
+    const counts = countBlock(block);
+    acc.ref += counts.ref;
+    acc.footnote += counts.footnote;
+  }
+  return bases;
+}
+var ReferenceBasesContext = createContext(null);
+var BlockReferenceScopeContext = createContext(null);
+function NcmReferencesProvider({ blocks, children }) {
+  const bases = useMemo(() => computeReferenceBases(blocks), [blocks]);
+  return /* @__PURE__ */ jsx(ReferenceBasesContext.Provider, { value: bases, children });
+}
+function BlockReferenceScope({ blockId, children }) {
+  const bases = useContext(ReferenceBasesContext);
+  const base = (blockId ? bases?.get(blockId) : void 0) ?? { ref: 0, footnote: 0 };
+  const counter = useRef({ ref: 0, footnote: 0 });
+  counter.current = { ref: 0, footnote: 0 };
+  const value = {
+    next(kind) {
+      counter.current[kind] += 1;
+      return base[kind] + counter.current[kind];
+    }
+  };
+  return /* @__PURE__ */ jsx(BlockReferenceScopeContext.Provider, { value, children });
+}
+function useBlockReferenceScope() {
+  return useContext(BlockReferenceScopeContext);
+}
+var INERT_SCOPE = { next: () => 0 };
+function InertReferenceScope({ children }) {
+  return /* @__PURE__ */ jsx(BlockReferenceScopeContext.Provider, { value: INERT_SCOPE, children });
+}
+
+export { BlockReferenceScope, InertReferenceScope, NcmProvider, NcmReferencesProvider, computeReferenceBases, useBlockReferenceScope, useNcmConfig };

package/dist/hooks/index.d.ts

@@ -0,0 +1,7 @@
+export { u as useNcmConfig } from '../use-ncm-config-D0doMYTH.js';
+export { useBlockRenderer, useCustomCodeRenderer } from './use-block-renderer.js';
+import 'react/jsx-runtime';
+import 'react';
+import '@nuucognition/mesh-core';
+import '@nuucognition/ncm';
+import '../renderers-C5f41FCy.js';