@astryxdesign/core 0.6.2 → 0.6.3-canary.01fa439

package/dist/Markdown/plugins/textTransform.js

@@ -0,0 +1,374 @@
+// Copyright (c) Meta Platforms, Inc. and affiliates.
+
+/**
+ * @file textTransform.ts
+ * @input Regex selectors and replacement callbacks for eligible Markdown prose
+ * @output Immutable Markdown transforms with protected-context traversal
+ * @position Optional helper layer compiled onto the core transform protocol
+ */
+
+import { getMarkdownHelperOwnership, adoptMarkdownHelperNode, adoptMarkdownHelperNodes, markMarkdownTransformClaim, markMarkdownTransformTrusted } from "./protocol.js";
+
+/**
+ * Ownership for a transform invoked outside Core's pipeline. It owns no
+ * plugin name and no renderer, so a callback's extension node is rejected
+ * while ordinary phrasing still works.
+ */
+const UNOWNED = Object.freeze({
+  pluginName: '\u0000unowned',
+  hasRenderer: () => false,
+  sourceUnchanged: false
+});
+/**
+ * Replacement nodes already placed in a document by this helper.
+ *
+ * A callback that builds a node per match hands over a fresh object, and
+ * that object can go straight into the tree — copying it would allocate a
+ * second one for nothing, and it is validated and frozen on the way in
+ * either way. A callback that returns the SAME object for several matches
+ * is the case that needs a copy: one object cannot occupy two positions in
+ * a tree, and a node already frozen into an earlier position must not be
+ * reused for a later one. Weak, so remembering a node never keeps it alive.
+ */
+const adoptedReplacements = new WeakSet();
+
+/** One reusable expression per transform invocation. */
+
+/**
+ * Copies a caller's node away from them. The cycle-tracking map is allocated
+ * only once a nested object actually appears: the overwhelmingly common
+ * replacement is a flat node of primitives, and this runs once per match.
+ */
+function cloneReplacement(value, seen) {
+  if (value == null || typeof value !== 'object') {
+    return value;
+  }
+  const cached = seen?.get(value);
+  if (cached != null) {
+    return cached;
+  }
+  if (Array.isArray(value)) {
+    const clone = [];
+    seen ??= new Map();
+    seen.set(value, clone);
+    for (const item of value) {
+      clone.push(cloneReplacement(item, seen));
+    }
+    return clone;
+  }
+  if (Object.getPrototypeOf(value) !== Object.prototype) {
+    return value;
+  }
+  const clone = {};
+  let tracked = seen;
+  for (const key in value) {
+    const nested = value[key];
+    if (nested != null && typeof nested === 'object') {
+      if (tracked === undefined) {
+        tracked = new Map();
+        tracked.set(value, clone);
+      }
+      clone[key] = cloneReplacement(nested, tracked);
+    } else {
+      clone[key] = nested;
+    }
+  }
+  return clone;
+}
+function advanceStringIndex(value, index, unicode) {
+  if (!unicode || index >= value.length) {
+    return index + 1;
+  }
+  const first = value.charCodeAt(index);
+  if (first < 0xd800 || first > 0xdbff || index + 1 >= value.length) {
+    return index + 1;
+  }
+  const second = value.charCodeAt(index + 1);
+  return second >= 0xdc00 && second <= 0xdfff ? index + 2 : index + 1;
+}
+function replaceTextNode(value, options, parentType, ownership, scanner) {
+  // The conservative substring hint decides per text node, not just per
+  // document: source without one cannot contain an eligible match, so most
+  // prose is skipped before any scanning happens.
+  // Disabled for case-insensitive patterns, exactly as the document-level
+  // claim is, so JavaScript case folding stays the only authority.
+  const required = options.pattern.ignoreCase ? undefined : options.requiredSubstrings;
+  if (required != null && !required.some(hint => value.includes(hint))) {
+    return null;
+  }
+  // One expression per transform invocation rather than one per text node.
+  // A `replace` callback that re-enters this helper gets its own, so a
+  // nested scan can never disturb the outer one's `lastIndex`.
+  const pattern = scanner.busy ? new RegExp(options.pattern.source, options.pattern.flags) : scanner.pattern;
+  const reentrant = pattern !== scanner.pattern;
+  if (!reentrant) {
+    scanner.busy = true;
+  }
+  pattern.lastIndex = 0;
+  const output = [];
+  let cursor = 0;
+  let changed = false;
+  let match;
+  while ((match = pattern.exec(value)) != null) {
+    const start = match.index;
+    const defaultEnd = start + match[0].length;
+    const resolvedEnd = options.getEndIndex?.(value, match) ?? defaultEnd;
+    if (resolvedEnd === false) {
+      if (match[0].length === 0) {
+        pattern.lastIndex = advanceStringIndex(value, pattern.lastIndex, pattern.unicode || pattern.flags.includes('v'));
+      }
+      continue;
+    }
+    if (!Number.isInteger(resolvedEnd) || resolvedEnd < defaultEnd || resolvedEnd < start || resolvedEnd > value.length) {
+      throw new TypeError('Markdown text transform returned an invalid end index');
+    }
+    if (start < cursor) {
+      continue;
+    }
+    if (start > cursor) {
+      output.push({
+        type: 'text',
+        value: value.slice(cursor, start)
+      });
+    }
+    const replacement = options.replace(match, {
+      parentType
+    });
+    // The callback's nodes are the only untrusted structure this helper can
+    // introduce. Each one is checked here under the same rules Core applies
+    // to newly-introduced nodes — representable data, no authored
+    // provenance, no foreign extension ownership, no cycles — and frozen,
+    // so the tree this transform returns needs no further checking. A node
+    // the callback has handed over before is copied first; a fresh one is
+    // adopted as it stands.
+    if (Array.isArray(replacement)) {
+      const adopted = [];
+      for (const replacementNode of replacement) {
+        adopted.push(adoptedReplacements.has(replacementNode) ? cloneReplacement(replacementNode) : replacementNode);
+      }
+      adoptMarkdownHelperNodes(adopted, ownership);
+      for (const node of adopted) {
+        adoptedReplacements.add(node);
+      }
+      output.push(...adopted);
+    } else {
+      // One node is the overwhelmingly common reply, and it is worth its
+      // own path: wrapping it in an array to share the loop above would
+      // allocate twice per match, which on a large document is the
+      // helper's dominant garbage.
+      const single = replacement;
+      const adopted = adoptedReplacements.has(single) ? cloneReplacement(single) : single;
+      adoptMarkdownHelperNode(adopted, ownership);
+      adoptedReplacements.add(adopted);
+      output.push(adopted);
+    }
+    cursor = resolvedEnd;
+    pattern.lastIndex = resolvedEnd === start ? advanceStringIndex(value, pattern.lastIndex, pattern.unicode || pattern.flags.includes('v')) : Math.max(pattern.lastIndex, resolvedEnd);
+    changed = true;
+  }
+  if (!reentrant) {
+    scanner.busy = false;
+  }
+  if (!changed) {
+    return null;
+  }
+  if (cursor < value.length) {
+    output.push({
+      type: 'text',
+      value: value.slice(cursor)
+    });
+  }
+  return output;
+}
+function transformPhrasing(children, options, parentType, ownership, scanner) {
+  // Lazy rebuild: unchanged phrasing is returned as-is, so prose with no
+  // match costs one walk and no allocation. Only the first change copies.
+  let next;
+  for (let index = 0; index < children.length; index++) {
+    const node = children[index];
+    if (node.type === 'text') {
+      const replaced = replaceTextNode(node.value, options, parentType, ownership, scanner);
+      if (replaced == null) {
+        next?.push(node);
+        continue;
+      }
+      next ??= children.slice(0, index);
+      for (const replacement of replaced) {
+        next.push(replacement);
+      }
+      continue;
+    }
+    if (node.type === 'strong' || node.type === 'emphasis' || node.type === 'delete') {
+      const nested = transformPhrasing(node.children, options, node.type, ownership, scanner);
+      if (nested === node.children) {
+        next?.push(node);
+        continue;
+      }
+      next ??= children.slice(0, index);
+      next.push({
+        ...node,
+        children: nested
+      });
+      continue;
+    }
+    // Links, images, code, math, citations, breaks, and accepted extension
+    // syntax are protected contexts owned by their existing semantics.
+    next?.push(node);
+  }
+  return next ?? children;
+}
+function blockMayContainRequiredSource(block, source, options) {
+  const required = options.requiredSubstrings;
+  if (source === undefined || required === undefined) {
+    return true;
+  }
+  const start = block.position?.start.offset;
+  const end = block.position?.end.offset;
+  if (typeof start !== 'number' || typeof end !== 'number') {
+    return true;
+  }
+  for (const hint of required) {
+    const match = source.indexOf(hint, start);
+    if (match >= 0 && match < end) {
+      return true;
+    }
+  }
+  return false;
+}
+function transformBlocks(blocks, options, ownership, scanner, source) {
+  // Lazy rebuild, matching transformPhrasing: a block list with no match is
+  // returned unchanged and allocates nothing.
+  let next;
+  for (let index = 0; index < blocks.length; index++) {
+    const block = blocks[index];
+    if (!blockMayContainRequiredSource(block, source, options)) {
+      next?.push(block);
+      continue;
+    }
+    let replacement;
+    switch (block.type) {
+      case 'heading':
+      case 'paragraph':
+        {
+          const children = transformPhrasing(block.children, options, block.type, ownership, scanner);
+          replacement = children === block.children ? block : {
+            ...block,
+            children
+          };
+          break;
+        }
+      case 'blockquote':
+        {
+          const children = transformBlocks(block.children, options, ownership, scanner, source);
+          replacement = children === block.children ? block : {
+            ...block,
+            children
+          };
+          break;
+        }
+      case 'list':
+        {
+          let items;
+          for (let item_index = 0; item_index < block.children.length; item_index++) {
+            const item = block.children[item_index];
+            const itemChildren = transformBlocks(item.children, options, ownership, scanner, source);
+            if (itemChildren === item.children) {
+              items?.push(item);
+              continue;
+            }
+            items ??= block.children.slice(0, item_index);
+            items.push({
+              ...item,
+              children: itemChildren
+            });
+          }
+          replacement = items == null ? block : {
+            ...block,
+            children: items
+          };
+          break;
+        }
+      case 'table':
+        {
+          let rows;
+          for (let row_index = 0; row_index < block.children.length; row_index++) {
+            const row = block.children[row_index];
+            let cells;
+            for (let cell_index = 0; cell_index < row.children.length; cell_index++) {
+              const cell = row.children[cell_index];
+              const cellChildren = transformPhrasing(cell.children, options, 'tableCell', ownership, scanner);
+              if (cellChildren === cell.children) {
+                cells?.push(cell);
+                continue;
+              }
+              cells ??= row.children.slice(0, cell_index);
+              cells.push({
+                ...cell,
+                children: cellChildren
+              });
+            }
+            if (cells == null) {
+              rows?.push(row);
+              continue;
+            }
+            rows ??= block.children.slice(0, row_index);
+            rows.push({
+              ...row,
+              children: cells
+            });
+          }
+          replacement = rows == null ? block : {
+            ...block,
+            children: rows
+          };
+          break;
+        }
+      case 'code':
+      case 'math':
+      case 'image':
+      case 'thematicBreak':
+      case 'extension':
+        replacement = block;
+        break;
+    }
+    if (next === undefined && replacement !== block) {
+      next = blocks.slice(0, index);
+    }
+    next?.push(replacement);
+  }
+  return next ?? blocks;
+}
+export function createMarkdownTextTransform(options) {
+  if (!options.pattern.global) {
+    throw new TypeError('Markdown text transform patterns must use the global flag');
+  }
+  if (options.requiredSubstrings != null && (!Array.isArray(options.requiredSubstrings) || options.requiredSubstrings.length === 0 || options.requiredSubstrings.some(value => typeof value !== 'string' || value === ''))) {
+    throw new TypeError('Markdown text transform requiredSubstrings must be non-empty strings');
+  }
+  const requiredSubstrings = options.requiredSubstrings == null ? undefined : Object.freeze([...options.requiredSubstrings]);
+  const normalizedOptions = Object.freeze({
+    pattern: new RegExp(options.pattern.source, options.pattern.flags),
+    requiredSubstrings,
+    getEndIndex: options.getEndIndex,
+    replace: options.replace
+  });
+  const transform = (root, context) => {
+    const ownership = getMarkdownHelperOwnership(context) ?? UNOWNED;
+    const children = transformBlocks(root.children, normalizedOptions, ownership, {
+      pattern: new RegExp(normalizedOptions.pattern.source, normalizedOptions.pattern.flags),
+      busy: false
+    }, ownership.sourceUnchanged && requiredSubstrings != null && !normalizedOptions.pattern.ignoreCase ? context.source : undefined);
+    return children === root.children ? root : {
+      ...root,
+      children
+    };
+  };
+  // Every node this helper returns is either one Core already validated or
+  // one `replaceTextNode` just validated against the same rules, so Core may
+  // run it on the trusted path.
+  const trusted = markMarkdownTransformTrusted(transform);
+  if (requiredSubstrings == null || options.pattern.ignoreCase) {
+    return trusted;
+  }
+  return markMarkdownTransformClaim(trusted, source => requiredSubstrings.some(required => source.includes(required)));
+}

package/dist/Markdown/remark.d.ts

@@ -0,0 +1,196 @@
+import { type MarkdownTransform } from './plugins/protocol';
+export interface MarkdownRemarkPoint {
+    line?: number;
+    column?: number;
+    offset?: number;
+}
+export interface MarkdownRemarkPosition {
+    start: MarkdownRemarkPoint;
+    end: MarkdownRemarkPoint;
+}
+export interface MarkdownRemarkNodeBase {
+    position?: MarkdownRemarkPosition;
+    data?: {
+        [key: string]: unknown;
+    };
+}
+export interface MarkdownRemarkText extends MarkdownRemarkNodeBase {
+    type: 'text';
+    value: string;
+}
+export interface MarkdownRemarkInlineCode extends MarkdownRemarkNodeBase {
+    type: 'inlineCode';
+    value: string;
+}
+export interface MarkdownRemarkInlineMath extends MarkdownRemarkNodeBase {
+    type: 'inlineMath';
+    value: string;
+}
+export interface MarkdownRemarkBreak extends MarkdownRemarkNodeBase {
+    type: 'break';
+}
+export interface MarkdownRemarkPhrasingParent<Type extends 'strong' | 'emphasis' | 'delete'> extends MarkdownRemarkNodeBase {
+    type: Type;
+    children: MarkdownRemarkPhrasingContent[];
+}
+export interface MarkdownRemarkLink extends MarkdownRemarkNodeBase {
+    type: 'link';
+    url: string;
+    /** Always `null` on input; a non-empty title cannot round-trip. */
+    title?: string | null;
+    children: MarkdownRemarkPhrasingContent[];
+}
+export interface MarkdownRemarkImage extends MarkdownRemarkNodeBase {
+    type: 'image';
+    url: string;
+    /** Always `null` on input; a non-empty title cannot round-trip. */
+    title?: string | null;
+    alt: string;
+}
+/** Astryx-owned citation. Read-only inside the adapter. */
+export interface MarkdownRemarkCitation extends MarkdownRemarkNodeBase {
+    type: 'citation';
+    sourceId: string;
+}
+/** Astryx-owned plugin extension node. Read-only inside the adapter. */
+export interface MarkdownRemarkExtension extends MarkdownRemarkNodeBase {
+    type: 'extension';
+    plugin: string;
+    name: string;
+    display: 'inline' | 'block';
+    source?: string;
+}
+export type MarkdownRemarkPhrasingContent = MarkdownRemarkText | MarkdownRemarkInlineCode | MarkdownRemarkInlineMath | MarkdownRemarkBreak | MarkdownRemarkPhrasingParent<'strong'> | MarkdownRemarkPhrasingParent<'emphasis'> | MarkdownRemarkPhrasingParent<'delete'> | MarkdownRemarkLink | MarkdownRemarkImage | MarkdownRemarkCitation | MarkdownRemarkExtension;
+export interface MarkdownRemarkHeading extends MarkdownRemarkNodeBase {
+    type: 'heading';
+    depth: 1 | 2 | 3 | 4 | 5 | 6;
+    children: MarkdownRemarkPhrasingContent[];
+}
+export interface MarkdownRemarkParagraph extends MarkdownRemarkNodeBase {
+    type: 'paragraph';
+    children: MarkdownRemarkPhrasingContent[];
+}
+export interface MarkdownRemarkCode extends MarkdownRemarkNodeBase {
+    type: 'code';
+    lang: string | null;
+    /** The authored info string after the language, `null` when absent. */
+    meta?: string | null;
+    value: string;
+}
+export interface MarkdownRemarkMath extends MarkdownRemarkNodeBase {
+    type: 'math';
+    value: string;
+}
+export interface MarkdownRemarkBlockquote extends MarkdownRemarkNodeBase {
+    type: 'blockquote';
+    children: MarkdownRemarkBlockContent[];
+}
+export interface MarkdownRemarkListItem extends MarkdownRemarkNodeBase {
+    type: 'listItem';
+    checked?: boolean | null;
+    /** Only a falsy value round-trips; Astryx has no loose-item contract. */
+    spread?: boolean | null;
+    children: MarkdownRemarkBlockContent[];
+}
+export interface MarkdownRemarkList extends MarkdownRemarkNodeBase {
+    type: 'list';
+    ordered: boolean;
+    start?: number | null;
+    spread?: boolean | null;
+    /** Astryx-preserved ordered-list marker delimiter. */
+    delimiter?: '.' | ')';
+    children: MarkdownRemarkListItem[];
+}
+export type MarkdownRemarkTableAlignment = 'left' | 'center' | 'right' | null;
+export interface MarkdownRemarkTableCell extends MarkdownRemarkNodeBase {
+    type: 'tableCell';
+    children: MarkdownRemarkPhrasingContent[];
+}
+export interface MarkdownRemarkTableRow extends MarkdownRemarkNodeBase {
+    type: 'tableRow';
+    children: MarkdownRemarkTableCell[];
+}
+export interface MarkdownRemarkTable extends MarkdownRemarkNodeBase {
+    type: 'table';
+    align: MarkdownRemarkTableAlignment[];
+    children: MarkdownRemarkTableRow[];
+}
+export interface MarkdownRemarkThematicBreak extends MarkdownRemarkNodeBase {
+    type: 'thematicBreak';
+}
+export type MarkdownRemarkBlockContent = MarkdownRemarkHeading | MarkdownRemarkParagraph | MarkdownRemarkCode | MarkdownRemarkMath | MarkdownRemarkBlockquote | MarkdownRemarkList | MarkdownRemarkTable | MarkdownRemarkThematicBreak | MarkdownRemarkImage | MarkdownRemarkExtension;
+export interface MarkdownRemarkRoot extends MarkdownRemarkNodeBase {
+    type: 'root';
+    children: MarkdownRemarkBlockContent[];
+}
+export interface MarkdownRemarkMessage {
+    reason: string;
+    fatal: boolean;
+    place: unknown;
+    ruleId: string | null;
+    toString(): string;
+}
+/**
+ * The isolated per-invocation file. It exposes readonly source text, finite
+ * JSON-like data, and diagnostics — never processor registration, cross-run
+ * state, a compiler, I/O, or asynchronous completion.
+ */
+export interface MarkdownRemarkFile {
+    readonly value: string;
+    readonly data: {
+        [key: string]: unknown;
+    };
+    readonly messages: MarkdownRemarkMessage[];
+    message(reason: string | Error, place?: unknown, ruleId?: string): MarkdownRemarkMessage;
+    fail(reason: string | Error, place?: unknown, ruleId?: string): never;
+    toString(): string;
+}
+/**
+ * A Remark transformer either mutates the tree and returns nothing or returns
+ * a replacement root, and an attacher may legitimately return nothing at all.
+ * Both shapes have to stay assignable, so `void` belongs in these unions.
+ */
+type Returned<Value> = Value | undefined | void;
+export type MarkdownRemarkTransformer = (tree: MarkdownRemarkRoot, file: MarkdownRemarkFile) => Returned<MarkdownRemarkRoot>;
+export type MarkdownRemarkPlugin<Settings extends ReadonlyArray<unknown> = readonly []> = (...settings: Settings) => Returned<MarkdownRemarkTransformer>;
+/**
+ * The structural shape a conventional Unified/Remark plugin already has. Its
+ * declared transformer may take Unified's callback parameter and may declare
+ * an asynchronous return union, so an existing typed plugin type-checks at the
+ * callsite without being rewritten. The adapter rejects an actual promise, and
+ * a callback-style transformer, at run time instead.
+ *
+ * Authoring a new plugin against Astryx? Annotate it with
+ * `MarkdownRemarkPlugin` to keep a typed tree and file.
+ */
+export type MarkdownRemarkCompatibleTransformer = (...args: never[]) => unknown;
+export type MarkdownRemarkCompatiblePlugin<Settings extends ReadonlyArray<unknown> = readonly []> = (...settings: Settings) => Returned<MarkdownRemarkCompatibleTransformer>;
+/**
+ * Adapt one synchronous transform-only Remark plugin to a Markdown transform.
+ *
+ * The adapted plugin receives a fresh mutable copy of the canonical document
+ * and an isolated constrained file. Every returned or mutated tree round-trips
+ * through the supported MDAST subset before it becomes observable; anything
+ * unsupported — a parser or compiler plugin, asynchronous work, processor
+ * state, raw HTML, an unsupported node, a forged position, or unrepresentable
+ * metadata — keeps the last valid document and reports one diagnostic.
+ *
+ * Compatibility is per plugin and proven by fixtures, never inferred from a
+ * package name.
+ *
+ * @example
+ * ```
+ * import {createMarkdownPlugin} from '@astryxdesign/core/Markdown';
+ * import {createMarkdownRemarkTransform} from '@astryxdesign/core/Markdown/remark';
+ *
+ * const shouting = createMarkdownPlugin({
+ *   name: 'shouting-headings',
+ *   apiVersion: 1,
+ *   transform: createMarkdownRemarkTransform(remarkShoutingHeadings),
+ * });
+ * ```
+ */
+export declare function createMarkdownRemarkTransform<Settings extends ReadonlyArray<unknown> = readonly []>(plugin: MarkdownRemarkPlugin<Settings>, ...settings: Settings): MarkdownTransform<never>;
+export declare function createMarkdownRemarkTransform<Settings extends ReadonlyArray<unknown> = readonly []>(plugin: MarkdownRemarkCompatiblePlugin<Settings>, ...settings: Settings): MarkdownTransform<never>;
+export {};
+//# sourceMappingURL=remark.d.ts.map

package/dist/Markdown/remark.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"remark.d.ts","sourceRoot":"","sources":["../../src/Markdown/remark.ts"],"names":[],"mappings":"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"}