@bendyline/squisq-editor-react 2.0.1 → 2.2.0

package/src/fileKind.ts

@@ -1,158 +0,0 @@
-/**
- * fileKind
- *
- * Maps a file name (or bare extension) to a Monaco language ID and decides
- * whether the editor shell should operate in markdown mode (full WYSIWYG +
- * Preview experience) or code mode (Monaco-only view with formatting
- * buttons hidden).
- *
- * The mapping favors common web / systems languages that Monaco ships with
- * out of the box. Unknown extensions fall back to markdown mode so the
- * existing UX remains the default for anything we don't recognize.
- */
-
-export interface FileKind {
-  /**
-   * 'markdown' keeps the full editor (WYSIWYG + Preview tabs); 'code' is
-   * Monaco-only; 'image' renders a dedicated image viewer with no text
-   * editing surface.
-   */
-  mode: 'markdown' | 'code' | 'image';
-  /** Monaco language ID — passed to `<Editor defaultLanguage={...} />`. */
-  language: string;
-}
-
-/**
- * Extension → Monaco language ID. Keys are lowercase, no leading dot.
- * Extend as needed; unknown extensions fall back to markdown mode.
- */
-const EXT_TO_LANGUAGE: Record<string, string> = {
-  md: 'markdown',
-  markdown: 'markdown',
-  mdown: 'markdown',
-  txt: 'plaintext',
-  ts: 'typescript',
-  tsx: 'typescript',
-  js: 'javascript',
-  jsx: 'javascript',
-  mjs: 'javascript',
-  cjs: 'javascript',
-  json: 'json',
-  jsonc: 'json',
-  html: 'html',
-  htm: 'html',
-  css: 'css',
-  scss: 'scss',
-  less: 'less',
-  py: 'python',
-  go: 'go',
-  rs: 'rust',
-  rb: 'ruby',
-  java: 'java',
-  c: 'c',
-  h: 'c',
-  cpp: 'cpp',
-  hpp: 'cpp',
-  cc: 'cpp',
-  cs: 'csharp',
-  php: 'php',
-  sh: 'shell',
-  bash: 'shell',
-  zsh: 'shell',
-  yml: 'yaml',
-  yaml: 'yaml',
-  toml: 'ini',
-  ini: 'ini',
-  xml: 'xml',
-  svg: 'xml',
-  sql: 'sql',
-  lua: 'lua',
-  swift: 'swift',
-  kt: 'kotlin',
-  kts: 'kotlin',
-  dockerfile: 'dockerfile',
-  png: 'image',
-  jpg: 'image',
-  jpeg: 'image',
-  gif: 'image',
-  webp: 'image',
-  bmp: 'image',
-  ico: 'image',
-  avif: 'image',
-};
-
-/**
- * Languages that keep the full markdown shell (WYSIWYG + Preview). Anything
- * outside this set is treated as code, except for languages in
- * `IMAGE_MODE_LANGUAGES`.
- */
-const MARKDOWN_MODE_LANGUAGES = new Set(['markdown', 'plaintext']);
-
-/**
- * Languages that switch the shell into image-viewer mode — no text editing
- * surface, no markdown chrome.
- */
-const IMAGE_MODE_LANGUAGES = new Set(['image']);
-
-/**
- * Pull the lowercase extension (no leading dot) from a file name or bare
- * extension string. Returns null when none is discernible.
- *
- * Examples:
- *   "foo.ts"       → "ts"
- *   "foo.tar.gz"   → "gz"
- *   ".ts"          → "ts"
- *   "ts"           → "ts"
- *   "Dockerfile"   → "dockerfile"   (full name match for extensionless files)
- *   ""             → null
- */
-function extractExtension(fileName: string): string | null {
-  const trimmed = fileName.trim();
-  if (!trimmed) return null;
-
-  // Strip any leading path — take only the basename.
-  const base = trimmed.replace(/^.*[/\\]/, '');
-  if (!base) return null;
-
-  const dotIdx = base.lastIndexOf('.');
-  if (dotIdx === -1) {
-    // No dot — could still be a recognized bare name (Dockerfile) or a bare
-    // extension passed by a caller like "ts". Lower-case and return.
-    return base.toLowerCase();
-  }
-  if (dotIdx === base.length - 1) return null; // Trailing dot, no extension.
-  return base.slice(dotIdx + 1).toLowerCase();
-}
-
-/**
- * Detect a Monaco language ID from a file name. Returns null when the
- * extension (or bare name) is not in the mapping.
- */
-export function detectLanguageFromFileName(fileName: string): string | null {
-  const ext = extractExtension(fileName);
-  if (!ext) return null;
-  return EXT_TO_LANGUAGE[ext] ?? null;
-}
-
-/**
- * Resolve the editor mode + Monaco language for a given file. The explicit
- * `language` argument, if provided, wins over any detection from
- * `fileName`. When nothing matches, falls back to markdown mode.
- */
-export function resolveFileKind(fileName?: string, language?: string): FileKind {
-  const resolvedLanguage = language ?? (fileName ? detectLanguageFromFileName(fileName) : null);
-
-  if (!resolvedLanguage) {
-    return { mode: 'markdown', language: 'markdown' };
-  }
-
-  let mode: FileKind['mode'];
-  if (IMAGE_MODE_LANGUAGES.has(resolvedLanguage)) {
-    mode = 'image';
-  } else if (MARKDOWN_MODE_LANGUAGES.has(resolvedLanguage)) {
-    mode = 'markdown';
-  } else {
-    mode = 'code';
-  }
-  return { mode, language: resolvedLanguage };
-}

package/src/frontmatter.ts

@@ -1,29 +0,0 @@
-/**
- * frontmatter
- *
- * Small helpers for the YAML frontmatter block at the top of a markdown
- * document. The WYSIWYG editor hides frontmatter from its editing surface
- * (and re-prepends it on save), and the block-at-a-time slicer
- * (`blockRange.ts`) needs to know where the body starts so it never folds
- * frontmatter into a block slice. Both share this one definition.
- */
-
-/** Regex matching a YAML frontmatter block at the start of the document. */
-export const FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?/;
-
-/** Strip YAML frontmatter from markdown, returning both parts. */
-export function stripFrontmatter(md: string): { body: string; frontmatter: string } {
-  const m = md.match(FRONTMATTER_RE);
-  if (!m) return { body: md, frontmatter: '' };
-  return { body: md.slice(m[0].length), frontmatter: m[0] };
-}
-
-/**
- * Character offset where the document body begins — i.e. the length of the
- * leading frontmatter block (including its trailing newline), or 0 when the
- * source has no frontmatter.
- */
-export function frontmatterEndOffset(source: string): number {
-  const m = source.match(FRONTMATTER_RE);
-  return m ? m[0].length : 0;
-}

package/src/frontmatterSettings.ts

@@ -1,23 +0,0 @@
-/** Canonical and legacy keys for frontmatter settings managed by the editor. */
-export const FRONTMATTER_SETTING_KEYS = {
-  theme: { canonical: 'squisq-theme', legacy: ['themeId', 'theme'] as const },
-  transform: { canonical: 'squisq-transform', legacy: 'transform-style' as const },
-  captions: { canonical: 'squisq-captions', legacy: 'caption-style' as const },
-  coverSlide: { canonical: 'squisq-cover-slide', legacy: 'cover-slide' as const },
-} as const;
-
-/** Runtime defaults whose equivalent frontmatter entries can be omitted. */
-export const FRONTMATTER_SETTING_DEFAULTS = {
-  theme: 'standard',
-  transform: '',
-  captions: 'standard',
-  coverSlide: true,
-} as const;
-
-/** Return `null` when a setting matches its runtime default so writers remove it. */
-export function omitFrontmatterDefault<T extends string | number | boolean>(
-  value: T,
-  defaultValue: T,
-): T | null {
-  return value === defaultValue ? null : value;
-}

package/src/headingTransition.ts

@@ -1,291 +0,0 @@
-/**
- * headingTransition
- *
- * Read and write a block's transition (`transition` / `transitionDirection` /
- * `transitionDuration`) on a heading, in both editing surfaces:
- *
- * - Markdown (Monaco): operate on the raw heading line string.
- * - WYSIWYG (Tiptap): operate on the heading node's `dataBlockAttrs` string
- *   (Pandoc `{…}` inner) and `dataTemplateParams` string (the params inside
- *   the squisq-native `{[…]}` annotation).
- *
- * The editor writes transitions to the squisq-native `{[…]}` annotation by
- * default. It still reads legacy Pandoc `{transition=…}` attributes and
- * removes/migrates those keys when rewriting, so the two channels cannot drift
- * after a toolbar edit.
- *
- * All the brace-matching / tokenizing / serializing is delegated to the
- * shared core helpers so this stays in lockstep with the parser by import
- * rather than by copied regexes.
- */
-
-import {
-  matchTrailingTemplateAnnotation,
-  matchTrailingPandocAttr,
-  parsePandocAttrTokens,
-  serializePandocAttributes,
-  tokenizeAttrTokens,
-  splitKeyValueToken,
-  quoteAttrValue,
-  type HeadingAttributes,
-} from '@bendyline/squisq/markdown';
-
-/** Raw (un-coerced) transition attribute values for one block. */
-export interface TransitionFields {
-  /** `transition` value. Empty string means "none" (`cut`). */
-  type: string;
-  /** `transitionDirection` value, or '' when unset. */
-  direction: string;
-  /** `transitionDuration` value (raw, e.g. `0.7` or `700ms`), or '' when unset. */
-  duration: string;
-}
-
-export const EMPTY_TRANSITION: TransitionFields = { type: '', direction: '', duration: '' };
-
-/** The three keys this module owns, in canonical emit order. */
-const TRANSITION_KEYS = ['transition', 'transitionDirection', 'transitionDuration'] as const;
-
-const HEADING_LINE_RE = /^(#{1,6}\s+)([\s\S]*)$/;
-
-// ============================================
-// params map ⇄ fields
-// ============================================
-
-function fieldsFromParams(params: Record<string, string> | undefined): TransitionFields {
-  if (!params) return { ...EMPTY_TRANSITION };
-  return {
-    type: params.transition ?? '',
-    direction: params.transitionDirection ?? '',
-    duration: params.transitionDuration ?? '',
-  };
-}
-
-/**
- * Return a new params map with the transition keys rewritten from `next`,
- * preserving every other key in its original order. When `type` is empty
- * (none), all three transition keys are dropped; direction/duration are only
- * written when a type is present (they're meaningless on their own).
- */
-function applyFieldsToParams(
-  params: Record<string, string>,
-  next: TransitionFields,
-): Record<string, string> {
-  const out: Record<string, string> = {};
-  for (const [key, value] of Object.entries(params)) {
-    if ((TRANSITION_KEYS as readonly string[]).includes(key)) continue;
-    out[key] = value;
-  }
-  if (next.type) {
-    out.transition = next.type;
-    if (next.direction) out.transitionDirection = next.direction;
-    if (next.duration) out.transitionDuration = next.duration;
-  }
-  return out;
-}
-
-function removeFieldsFromAttrs(attrs: HeadingAttributes): HeadingAttributes {
-  if (!attrs.params) return attrs;
-  const params = applyFieldsToParams(attrs.params, EMPTY_TRANSITION);
-  if (Object.keys(params).length > 0) attrs.params = params;
-  else delete attrs.params;
-  return attrs;
-}
-
-/** Parse a bare `key=value …` token string into a params map. */
-function paramsFromTokenString(input: string, skipFirstToken: boolean): Record<string, string> {
-  const tokens = tokenizeAttrTokens(input);
-  const params: Record<string, string> = {};
-  for (const token of skipFirstToken ? tokens.slice(1) : tokens) {
-    const kv = splitKeyValueToken(token);
-    if (kv) params[kv.key] = kv.value;
-  }
-  return params;
-}
-
-function templatePartsFromInner(inner: string | null | undefined): {
-  template: string | undefined;
-  params: Record<string, string>;
-} {
-  if (!inner) return { template: undefined, params: {} };
-  const tokens = tokenizeAttrTokens(inner);
-  const firstIsParam = tokens.length > 0 && tokens[0].indexOf('=') > 0;
-  const template = firstIsParam || tokens.length === 0 ? undefined : tokens[0];
-  const startIdx = template ? 1 : 0;
-  const params: Record<string, string> = {};
-  for (const token of tokens.slice(startIdx)) {
-    const kv = splitKeyValueToken(token);
-    if (kv) params[kv.key] = kv.value;
-  }
-  return { template, params };
-}
-
-function paramsToInner(params: Record<string, string>): string | null {
-  const parts = Object.entries(params).map(([key, value]) => `${key}=${quoteAttrValue(value)}`);
-  return parts.length > 0 ? parts.join(' ') : null;
-}
-
-function templateAnnotationOrNull(
-  template: string | undefined,
-  params: Record<string, string>,
-): string | null {
-  const parts: string[] = [];
-  if (template) parts.push(template);
-  const paramInner = paramsToInner(params);
-  if (paramInner) parts.push(paramInner);
-  return parts.length > 0 ? `{[${parts.join(' ')}]}` : null;
-}
-
-// ============================================
-// Heading line (Markdown / Monaco view)
-// ============================================
-
-interface SplitHeadingLine {
-  /** `## ` */
-  prefix: string;
-  /** Bare heading text (trailing whitespace stripped). */
-  text: string;
-  /** Inner of the trailing Pandoc `{…}` block, or null. */
-  pandocInner: string | null;
-  /** Verbatim trailing `{[…]}` template annotation (no leading space), or ''. */
-  templateText: string;
-}
-
-/**
- * Split a heading line into its prefix, bare text, and trailing annotation
- * blocks. Mirrors the peel-off order in `tiptapBridge` / core's parser:
- * the `{[…]}` template annotation sits at the very end, the Pandoc `{…}`
- * block just before it. Returns null when `line` is not a heading.
- */
-function splitHeadingLine(line: string): SplitHeadingLine | null {
-  const m = line.match(HEADING_LINE_RE);
-  if (!m) return null;
-  let rest = m[2];
-
-  let templateText = '';
-  const tm = matchTrailingTemplateAnnotation(rest);
-  if (tm) {
-    templateText = rest.slice(tm.index).trim();
-    rest = rest.slice(0, tm.index);
-  }
-
-  let pandocInner: string | null = null;
-  const pm = matchTrailingPandocAttr(rest);
-  if (pm) {
-    pandocInner = pm.inner;
-    rest = rest.slice(0, pm.index);
-  }
-
-  return { prefix: m[1], text: rest.replace(/\s+$/, ''), pandocInner, templateText };
-}
-
-/**
- * Read the transition fields off a heading line. Looks in both the Pandoc
- * `{…}` block (legacy) and the `{[…]}` template params (canonical),
- * with the Pandoc block taking precedence. Returns the empty transition for
- * non-heading lines.
- */
-export function readHeadingLineTransition(line: string): TransitionFields {
-  const split = splitHeadingLine(line);
-  if (!split) return { ...EMPTY_TRANSITION };
-  const fromTemplate = split.templateText
-    ? templatePartsFromInner(stripTemplateBraces(split.templateText)).params
-    : {};
-  const fromPandoc = split.pandocInner
-    ? (parsePandocAttrTokens(split.pandocInner).params ?? {})
-    : {};
-  return fieldsFromParams({ ...fromTemplate, ...fromPandoc });
-}
-
-/**
- * Return `line` with its transition rewritten from `next`, writing into the
- * squisq-native `{[…]}` annotation. Legacy Pandoc transition keys are removed
- * while preserving ids, classes, and other Pandoc params. Non-heading lines are
- * returned unchanged.
- */
-export function setHeadingLineTransition(line: string, next: TransitionFields): string {
-  const split = splitHeadingLine(line);
-  if (!split) return line;
-  const attrs: HeadingAttributes = split.pandocInner
-    ? parsePandocAttrTokens(split.pandocInner)
-    : {};
-  removeFieldsFromAttrs(attrs);
-  const pandoc = pandocBlockOrNull(attrs);
-
-  const templateParts = templatePartsFromInner(
-    split.templateText ? stripTemplateBraces(split.templateText) : null,
-  );
-  const templateParams = applyFieldsToParams(templateParts.params, next);
-  const template = templateAnnotationOrNull(templateParts.template, templateParams);
-
-  let out = split.prefix + split.text;
-  if (pandoc) out += ` ${pandoc}`;
-  if (template) out += ` ${template}`;
-  return out;
-}
-
-/** Strip the outer `{[` … `]}` from a verbatim template annotation. */
-function stripTemplateBraces(templateText: string): string {
-  const m = templateText.match(/^\{\[([\s\S]*)\]\}[\s\]}]*$/);
-  return m ? m[1] : templateText;
-}
-
-// ============================================
-// data-block-attrs (WYSIWYG / Tiptap view)
-// ============================================
-
-/**
- * Read the transition fields from a heading node's `dataBlockAttrs` (legacy
- * Pandoc inner) plus `dataTemplateParams` (canonical `{[…]}` params). Pandoc
- * wins so the picker mirrors the value that `markdownToDoc` will render when
- * both channels are present.
- */
-export function readBlockAttrsTransition(
-  blockAttrsInner: string | null | undefined,
-  templateParams: string | null | undefined,
-): TransitionFields {
-  const fromTemplate = templateParams ? paramsFromTokenString(templateParams, false) : {};
-  const fromPandoc = blockAttrsInner ? (parsePandocAttrTokens(blockAttrsInner).params ?? {}) : {};
-  return fieldsFromParams({ ...fromTemplate, ...fromPandoc });
-}
-
-export interface HeadingTransitionAttrs {
-  /** Inner of the Pandoc `{…}` block, without braces. */
-  blockAttrsInner: string | null;
-  /** Param string inside the `{[…]}` annotation, without the template token. */
-  templateParams: string | null;
-}
-
-/**
- * Rewrite a heading node's transition for Tiptap, writing the transition
- * family into `dataTemplateParams` and removing any legacy transition keys
- * from `dataBlockAttrs`.
- */
-export function setHeadingAttrsTransition(
-  blockAttrsInner: string | null | undefined,
-  templateParams: string | null | undefined,
-  next: TransitionFields,
-): HeadingTransitionAttrs {
-  const attrs: HeadingAttributes = blockAttrsInner ? parsePandocAttrTokens(blockAttrsInner) : {};
-  removeFieldsFromAttrs(attrs);
-  const pandoc = pandocBlockOrNull(attrs);
-
-  const params = applyFieldsToParams(paramsFromTokenString(templateParams ?? '', false), next);
-  return {
-    blockAttrsInner: pandoc ? pandoc.slice(1, -1) : null,
-    templateParams: paramsToInner(params),
-  };
-}
-
-// ============================================
-// shared
-// ============================================
-
-/**
- * Serialize `attrs` to a `{…}` block, or null when there's nothing to emit.
- * `serializePandocAttributes` returns the literal `{}` marker for an empty
- * attribute set; we treat that as "no block".
- */
-function pandocBlockOrNull(attrs: HeadingAttributes): string | null {
-  const raw = serializePandocAttributes(attrs);
-  return raw == null || raw === '{}' ? null : raw;
-}