@xyd-js/content 0.1.0-xyd.8 → 0.1.0-xyd.97

package/packages/md/plugins/output-variables/__fixtures__/2.multiple-vars/output.json

@@ -0,0 +1,127 @@
+{
+    "type": "root",
+    "children": [
+      {
+        "type": "outputVars",
+        "name": "example",
+        "attributes": {},
+        "children": [
+          {
+            "type": "code",
+            "lang": "bash",
+            "meta": "npm",
+            "value": "npm i -g xyd-js",
+            "position": {
+              "start": {
+                "line": 2,
+                "column": 3,
+                "offset": 13
+              },
+              "end": {
+                "line": 4,
+                "column": 6,
+                "offset": 48
+              }
+            }
+          },
+          {
+            "type": "code",
+            "lang": "bash",
+            "meta": "yarn",
+            "value": "yarn global add xyd-js",
+            "position": {
+              "start": {
+                "line": 6,
+                "column": 3,
+                "offset": 52
+              },
+              "end": {
+                "line": 8,
+                "column": 6,
+                "offset": 95
+              }
+            }
+          },
+          {
+            "type": "code",
+            "lang": "bash",
+            "meta": "pnpm",
+            "value": "pnpm add -g xyd-js",
+            "position": {
+              "start": {
+                "line": 10,
+                "column": 3,
+                "offset": 99
+              },
+              "end": {
+                "line": 12,
+                "column": 6,
+                "offset": 138
+              }
+            }
+          }
+        ],
+        "position": {
+          "start": {
+            "line": 1,
+            "column": 1,
+            "offset": 0
+          },
+          "end": {
+            "line": 13,
+            "column": 4,
+            "offset": 142
+          }
+        }
+      },
+      {
+        "type": "outputVars",
+        "name": "example2",
+        "attributes": {},
+        "children": [
+          {
+            "type": "code",
+            "lang": "tsx",
+            "meta": null,
+            "value": "function() {\n  return <div> Hello World </div>\n}",
+            "position": {
+              "start": {
+                "line": 16,
+                "column": 3,
+                "offset": 158
+              },
+              "end": {
+                "line": 20,
+                "column": 6,
+                "offset": 225
+              }
+            }
+          }
+        ],
+        "position": {
+          "start": {
+            "line": 15,
+            "column": 1,
+            "offset": 144
+          },
+          "end": {
+            "line": 21,
+            "column": 4,
+            "offset": 229
+          }
+        }
+      }
+    ],
+    "position": {
+      "start": {
+        "line": 1,
+        "column": 1,
+        "offset": 0
+      },
+      "end": {
+        "line": 22,
+        "column": 1,
+        "offset": 230
+      }
+    }
+  }

package/packages/md/plugins/output-variables/__tests__/index.test.ts

@@ -0,0 +1,28 @@
+import { describe, it } from 'vitest';
+
+import { testFixture } from './testHelpers';
+
+const tests = [
+    {
+        name: "1.simple",
+        description: "A simple example of output variables",
+        input: "1.simple/input.md",
+        output: "1.simple/output.json"
+    },
+    {
+        name: "2.multiple-vars",
+        description: "A example of multiple output variables",
+        input: "2.multiple-vars/input.md",
+        output: "2.multiple-vars/output.json"
+    }
+
+]
+
+describe("outputVars", () => {
+    tests.forEach((test) => {
+        it(`[${test.name}]: ${test.description}`, async () => {
+            await testFixture(test.name);
+        });
+    });
+});
+

package/packages/md/plugins/output-variables/__tests__/testHelpers.ts

@@ -0,0 +1,36 @@
+import path from 'node:path';
+import fs from 'node:fs';
+
+import { remark } from 'remark'
+import { expect } from 'vitest';
+
+import { remarkOutputVars } from '../remarkOutputVars';
+
+const fixturesDir = path.resolve(__dirname, '../__fixtures__');
+
+// Helper function to run a test with a specific fixture
+export async function testFixture(fixtureName: string) {
+    const input = readFixture(`${fixtureName}/input.md`);
+    const expectedOutput = readFixtureOutput(`${fixtureName}/output.json`);
+
+    const result = await processMarkdown(input)
+    expect(result).toEqual(expectedOutput);
+}
+
+// Helper function to read fixture files
+function readFixture(name: string) {
+    const fixturePath = path.join(fixturesDir, name);
+    return fs.readFileSync(fixturePath, "utf8");
+}
+
+// Helper function to read fixture output
+function readFixtureOutput(name: string) {
+    const fixturePath = path.join(fixturesDir, name);
+    return JSON.parse(fs.readFileSync(fixturePath, "utf8"));
+}
+
+function processMarkdown(input: string) {
+    return remark()
+        .use(remarkOutputVars)
+        .parse(input)
+}

package/packages/md/plugins/output-variables/index.ts

@@ -0,0 +1 @@
+export { remarkOutputVars as outputVars } from './remarkOutputVars'

package/packages/md/plugins/output-variables/lib/const.ts

@@ -0,0 +1,4 @@
+import { codes } from 'micromark-util-symbol'
+
+export const PRIMARY_SYMBOL = codes.lessThan
+export const PRIMARY_SYMBOL_STR = '>'

package/packages/md/plugins/output-variables/lib/factoryAttributes.ts

@@ -0,0 +1,350 @@
+/**
+ * @import {Code, Effects, State, TokenType} from 'micromark-util-types'
+ */
+
+import {ok as assert} from 'devlop'
+import {factorySpace} from 'micromark-factory-space'
+import {factoryWhitespace} from 'micromark-factory-whitespace'
+import {
+  markdownLineEnding,
+  markdownLineEndingOrSpace,
+  markdownSpace,
+  unicodePunctuation,
+  unicodeWhitespace
+} from 'micromark-util-character'
+import {codes, types} from 'micromark-util-symbol'
+
+import { PRIMARY_SYMBOL } from './const'
+
+/**
+ * @param {Effects} effects
+ * @param {State} ok
+ * @param {State} nok
+ * @param {TokenType} attributesType
+ * @param {TokenType} attributesMarkerType
+ * @param {TokenType} attributeType
+ * @param {TokenType} attributeIdType
+ * @param {TokenType} attributeClassType
+ * @param {TokenType} attributeNameType
+ * @param {TokenType} attributeInitializerType
+ * @param {TokenType} attributeValueLiteralType
+ * @param {TokenType} attributeValueType
+ * @param {TokenType} attributeValueMarker
+ * @param {TokenType} attributeValueData
+ * @param {boolean | undefined} [disallowEol=false]
+ */
+export function factoryAttributes(
+  effects,
+  ok,
+  nok,
+  attributesType,
+  attributesMarkerType,
+  attributeType,
+  attributeIdType,
+  attributeClassType,
+  attributeNameType,
+  attributeInitializerType,
+  attributeValueLiteralType,
+  attributeValueType,
+  attributeValueMarker,
+  attributeValueData,
+  disallowEol
+) {
+  /** @type {TokenType} */
+  let type
+  /** @type {Code | undefined} */
+  let marker
+
+  return start
+
+  /** @type {State} */
+  function start(code) {
+    assert(code === codes.leftCurlyBrace, 'expected `{`')
+    effects.enter(attributesType)
+    effects.enter(attributesMarkerType)
+    effects.consume(code)
+    effects.exit(attributesMarkerType)
+    return between
+  }
+
+  /** @type {State} */
+  function between(code) {
+    if (code === codes.numberSign) {
+      type = attributeIdType
+      return shortcutStart(code)
+    }
+
+    if (code === codes.dot) {
+      type = attributeClassType
+      return shortcutStart(code)
+    }
+
+    if (disallowEol && markdownSpace(code)) {
+      return factorySpace(effects, between, types.whitespace)(code)
+    }
+
+    if (!disallowEol && markdownLineEndingOrSpace(code)) {
+      return factoryWhitespace(effects, between)(code)
+    }
+
+    if (
+      code === codes.eof ||
+      markdownLineEnding(code) ||
+      unicodeWhitespace(code) ||
+      (unicodePunctuation(code) &&
+        code !== codes.dash &&
+        code !== codes.underscore)
+    ) {
+      return end(code)
+    }
+
+    effects.enter(attributeType)
+    effects.enter(attributeNameType)
+    effects.consume(code)
+    return name
+  }
+
+  /** @type {State} */
+  function shortcutStart(code) {
+    // Assume it’s registered.
+    const markerType = /** @type {TokenType} */ (type + 'Marker')
+    effects.enter(attributeType)
+    effects.enter(type)
+    effects.enter(markerType)
+    effects.consume(code)
+    effects.exit(markerType)
+    return shortcutStartAfter
+  }
+
+  /** @type {State} */
+  function shortcutStartAfter(code) {
+    if (
+      code === codes.eof ||
+      code === codes.quotationMark ||
+      code === codes.numberSign ||
+      code === codes.apostrophe ||
+      code === codes.dot ||
+      code === codes.lessThan ||
+      code === codes.equalsTo ||
+      code === codes.greaterThan ||
+      code === codes.graveAccent ||
+      code === codes.rightCurlyBrace ||
+      markdownLineEndingOrSpace(code)
+    ) {
+      return nok(code)
+    }
+
+    // Assume it’s registered.
+    const valueType = /** @type {TokenType} */ (type + 'Value')
+    effects.enter(valueType)
+    effects.consume(code)
+    return shortcut
+  }
+
+  /** @type {State} */
+  function shortcut(code) {
+    if (
+      code === codes.eof ||
+      code === codes.quotationMark ||
+      code === codes.apostrophe ||
+      code === codes.lessThan ||
+      code === codes.equalsTo ||
+      code === codes.greaterThan ||
+      code === codes.graveAccent
+    ) {
+      return nok(code)
+    }
+
+    if (
+      code === codes.numberSign ||
+      code === codes.dot ||
+      code === codes.rightCurlyBrace ||
+      markdownLineEndingOrSpace(code)
+    ) {
+      // Assume it’s registered.
+      const valueType = /** @type {TokenType} */ (type + 'Value')
+      effects.exit(valueType)
+      effects.exit(type)
+      effects.exit(attributeType)
+      return between(code)
+    }
+
+    effects.consume(code)
+    return shortcut
+  }
+
+  /** @type {State} */
+  function name(code) {
+    if (
+      code === codes.eof ||
+      markdownLineEnding(code) ||
+      unicodeWhitespace(code) ||
+      (unicodePunctuation(code) &&
+        code !== codes.dash &&
+        code !== codes.dot &&
+        code !== PRIMARY_SYMBOL &&
+        code !== codes.underscore)
+    ) {
+      effects.exit(attributeNameType)
+
+      if (disallowEol && markdownSpace(code)) {
+        return factorySpace(effects, nameAfter, types.whitespace)(code)
+      }
+
+      if (!disallowEol && markdownLineEndingOrSpace(code)) {
+        return factoryWhitespace(effects, nameAfter)(code)
+      }
+
+      return nameAfter(code)
+    }
+
+    effects.consume(code)
+    return name
+  }
+
+  /** @type {State} */
+  function nameAfter(code) {
+    if (code === codes.equalsTo) {
+      effects.enter(attributeInitializerType)
+      effects.consume(code)
+      effects.exit(attributeInitializerType)
+      return valueBefore
+    }
+
+    // Attribute w/o value.
+    effects.exit(attributeType)
+    return between(code)
+  }
+
+  /** @type {State} */
+  function valueBefore(code) {
+    if (
+      code === codes.eof ||
+      code === codes.lessThan ||
+      code === codes.equalsTo ||
+      code === codes.greaterThan ||
+      code === codes.graveAccent ||
+      code === codes.rightCurlyBrace ||
+      (disallowEol && markdownLineEnding(code))
+    ) {
+      return nok(code)
+    }
+
+    if (code === codes.quotationMark || code === codes.apostrophe) {
+      effects.enter(attributeValueLiteralType)
+      effects.enter(attributeValueMarker)
+      effects.consume(code)
+      effects.exit(attributeValueMarker)
+      marker = code
+      return valueQuotedStart
+    }
+
+    if (disallowEol && markdownSpace(code)) {
+      return factorySpace(effects, valueBefore, types.whitespace)(code)
+    }
+
+    if (!disallowEol && markdownLineEndingOrSpace(code)) {
+      return factoryWhitespace(effects, valueBefore)(code)
+    }
+
+    effects.enter(attributeValueType)
+    effects.enter(attributeValueData)
+    effects.consume(code)
+    marker = undefined
+    return valueUnquoted
+  }
+
+  /** @type {State} */
+  function valueUnquoted(code) {
+    if (
+      code === codes.eof ||
+      code === codes.quotationMark ||
+      code === codes.apostrophe ||
+      code === codes.lessThan ||
+      code === codes.equalsTo ||
+      code === codes.greaterThan ||
+      code === codes.graveAccent
+    ) {
+      return nok(code)
+    }
+
+    if (code === codes.rightCurlyBrace || markdownLineEndingOrSpace(code)) {
+      effects.exit(attributeValueData)
+      effects.exit(attributeValueType)
+      effects.exit(attributeType)
+      return between(code)
+    }
+
+    effects.consume(code)
+    return valueUnquoted
+  }
+
+  /** @type {State} */
+  function valueQuotedStart(code) {
+    if (code === marker) {
+      effects.enter(attributeValueMarker)
+      effects.consume(code)
+      effects.exit(attributeValueMarker)
+      effects.exit(attributeValueLiteralType)
+      effects.exit(attributeType)
+      return valueQuotedAfter
+    }
+
+    effects.enter(attributeValueType)
+    return valueQuotedBetween(code)
+  }
+
+  /** @type {State} */
+  function valueQuotedBetween(code) {
+    if (code === marker) {
+      effects.exit(attributeValueType)
+      return valueQuotedStart(code)
+    }
+
+    if (code === codes.eof) {
+      return nok(code)
+    }
+
+    // Note: blank lines can’t exist in content.
+    if (markdownLineEnding(code)) {
+      return disallowEol
+        ? nok(code)
+        : factoryWhitespace(effects, valueQuotedBetween)(code)
+    }
+
+    effects.enter(attributeValueData)
+    effects.consume(code)
+    return valueQuoted
+  }
+
+  /** @type {State} */
+  function valueQuoted(code) {
+    if (code === marker || code === codes.eof || markdownLineEnding(code)) {
+      effects.exit(attributeValueData)
+      return valueQuotedBetween(code)
+    }
+
+    effects.consume(code)
+    return valueQuoted
+  }
+
+  /** @type {State} */
+  function valueQuotedAfter(code) {
+    return code === codes.rightCurlyBrace || markdownLineEndingOrSpace(code)
+      ? between(code)
+      : end(code)
+  }
+
+  /** @type {State} */
+  function end(code) {
+    if (code === codes.rightCurlyBrace) {
+      effects.enter(attributesMarkerType)
+      effects.consume(code)
+      effects.exit(attributesMarkerType)
+      effects.exit(attributesType)
+      return ok
+    }
+
+    return nok(code)
+  }
+}

package/packages/md/plugins/output-variables/lib/factoryLabel.ts

@@ -0,0 +1,135 @@
+/**
+ * @import {Code, Effects, State, Token, TokenType} from 'micromark-util-types'
+ */
+
+import {ok as assert} from 'devlop'
+import {markdownLineEnding} from 'micromark-util-character'
+import {codes, constants, types} from 'micromark-util-symbol'
+
+// This is a fork of:
+// <https://github.com/micromark/micromark/tree/main/packages/micromark-factory-label>
+// to allow empty labels, balanced brackets (such as for nested directives),
+// text instead of strings, and optionally disallows EOLs.
+
+/**
+ * @param {Effects} effects
+ * @param {State} ok
+ * @param {State} nok
+ * @param {TokenType} type
+ * @param {TokenType} markerType
+ * @param {TokenType} stringType
+ * @param {boolean | undefined} [disallowEol=false]
+ */
+export function factoryLabel(
+  effects,
+  ok,
+  nok,
+  type,
+  markerType,
+  stringType,
+  disallowEol
+) {
+  let size = 0
+  let balance = 0
+  /** @type {Token | undefined} */
+  let previous
+
+  return start
+
+  /** @type {State} */
+  function start(code) {
+    assert(code === codes.leftSquareBracket, 'expected `[`')
+    effects.enter(type)
+    effects.enter(markerType)
+    effects.consume(code)
+    effects.exit(markerType)
+    return afterStart
+  }
+
+  /** @type {State} */
+  function afterStart(code) {
+    if (code === codes.rightSquareBracket) {
+      effects.enter(markerType)
+      effects.consume(code)
+      effects.exit(markerType)
+      effects.exit(type)
+      return ok
+    }
+
+    effects.enter(stringType)
+    return lineStart(code)
+  }
+
+  /** @type {State} */
+  function lineStart(code) {
+    if (code === codes.rightSquareBracket && !balance) {
+      return atClosingBrace(code)
+    }
+
+    const token = effects.enter(types.chunkText, {
+      _contentTypeTextTrailing: true,
+      contentType: constants.contentTypeText,
+      previous
+    })
+    if (previous) previous.next = token
+    previous = token
+    return data(code)
+  }
+
+  /** @type {State} */
+  function data(code) {
+    if (code === codes.eof || size > constants.linkReferenceSizeMax) {
+      return nok(code)
+    }
+
+    if (
+      code === codes.leftSquareBracket &&
+      ++balance > constants.linkResourceDestinationBalanceMax
+    ) {
+      return nok(code)
+    }
+
+    if (code === codes.rightSquareBracket && !balance--) {
+      effects.exit(types.chunkText)
+      return atClosingBrace(code)
+    }
+
+    if (markdownLineEnding(code)) {
+      if (disallowEol) {
+        return nok(code)
+      }
+
+      effects.consume(code)
+      effects.exit(types.chunkText)
+      return lineStart
+    }
+
+    effects.consume(code)
+    return code === codes.backslash ? dataEscape : data
+  }
+
+  /** @type {State} */
+  function dataEscape(code) {
+    if (
+      code === codes.leftSquareBracket ||
+      code === codes.backslash ||
+      code === codes.rightSquareBracket
+    ) {
+      effects.consume(code)
+      size++
+      return data
+    }
+
+    return data(code)
+  }
+
+  /** @type {State} */
+  function atClosingBrace(code) {
+    effects.exit(stringType)
+    effects.enter(markerType)
+    effects.consume(code)
+    effects.exit(markerType)
+    effects.exit(type)
+    return ok
+  }
+}