moonbit-syntax-highlighter 0.1.0 → 0.1.1

package/README.md

@@ -2,7 +2,10 @@
 
 Reusable MoonBit syntax grammar package for front-end documentation tooling.
 
-This package vendors a MoonBit TextMate-style syntax definition and exposes stable Node-side entry points that documentation tools can consume.
+This package ships two layers:
+
+- the original MIT-licensed MoonBit Sublime syntax source for reuse and attribution
+- a Shiki-compatible TextMate grammar registration for documentation stacks such as VitePress
 
 It is framework-agnostic by design: the package ships raw grammar access, metadata, and a small registration helper instead of binding itself to a single docs stack.
 
@@ -11,8 +14,9 @@ It is framework-agnostic by design: the package ships raw grammar access, metada
 - `moonbitGrammarPath`: absolute local path to the vendored `moonbit.sublime-syntax`
 - `moonbitGrammar`: raw grammar file contents as a string
 - `readMoonbitGrammar()`: reads the packaged grammar from disk
+- `moonbitTextMateGrammar`: a Shiki-compatible TextMate grammar object for MoonBit
 - `moonbitLanguage`: language metadata for consumers that accept a custom language registration object
-- `createMoonbitLanguageRegistration()`: returns metadata plus inline grammar content for tools that prefer in-memory registration
+- `createMoonbitLanguageRegistration()`: returns metadata plus a Shiki-compatible grammar object for tools that prefer in-memory registration
 - `moonbitAliases`: common aliases such as `moonbit`, `mbt`, and `mbti`
 
 ## Install
@@ -26,13 +30,13 @@ pnpm add moonbit-syntax-highlighter
 ```js
 import {
   createMoonbitLanguageRegistration,
-  moonbitGrammarPath,
+  moonbitTextMateGrammar,
 } from 'moonbit-syntax-highlighter'
 
 const language = createMoonbitLanguageRegistration()
 
 console.log(language.scopeName)
-console.log(moonbitGrammarPath)
+console.log(moonbitTextMateGrammar.scopeName)
 ```
 
 ```js
@@ -41,6 +45,23 @@ import { moonbitGrammar } from 'moonbit-syntax-highlighter/content'
 console.log(moonbitGrammar.slice(0, 40))
 ```
 
+```js
+import { createHighlighter } from 'shiki'
+import { createMoonbitLanguageRegistration } from 'moonbit-syntax-highlighter'
+
+const highlighter = await createHighlighter({
+  themes: ['github-light'],
+  langs: [createMoonbitLanguageRegistration()],
+})
+
+const html = highlighter.codeToHtml('pub fn main() -> Int {\n  return 1\n}', {
+  lang: 'moonbit',
+  theme: 'github-light',
+})
+
+console.log(html)
+```
+
 ## Intended Consumers
 
 - Shiki-based documentation sites such as VitePress or Astro
@@ -58,7 +79,7 @@ This package preserves upstream attribution in `LICENSE.upstream` and is intende
 
 ## Current Scope
 
-This first version focuses on packaging and reuse. It does not yet add framework-specific adapters, snapshot tests, or MoonBit-specific semantic highlighting.
+This package currently focuses on practical static highlighting for docs and examples. It does not yet provide semantic highlighting, Markdown injection grammars, or editor-specific extension packaging.
 
 ## Local Development
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "moonbit-syntax-highlighter",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Reusable MoonBit syntax grammar package for documentation tooling and front-end highlighters.",
   "author": "Nanaloveyuki",
   "license": "MIT",
@@ -35,6 +35,9 @@
     "check": "node scripts/check.js",
     "pack:check": "pnpm pack --pack-destination .pack"
   },
+  "dependencies": {
+    "shiki": "^4.2.0"
+  },
   "types": "./src/index.d.ts",
   "exports": {
     ".": {
@@ -53,6 +56,10 @@
       "types": "./src/shiki.d.ts",
       "default": "./src/shiki.js"
     },
+    "./textmate": {
+      "types": "./src/textmate.d.ts",
+      "default": "./src/textmate.js"
+    },
     "./syntaxes/moonbit.sublime-syntax": "./syntaxes/moonbit.sublime-syntax",
     "./package.json": "./package.json"
   },

package/src/index.d.ts

@@ -3,5 +3,6 @@ export { moonbitGrammar, readMoonbitGrammar } from './content.js'
 export {
   createMoonbitLanguageRegistration,
   moonbitLanguage,
+  moonbitTextMateGrammar,
 } from './shiki.js'
 export type { MoonbitLanguageRegistration } from './shiki.js'

package/src/index.js

@@ -1,3 +1,3 @@
 export { moonbitAliases, moonbitGrammarPath, moonbitScopeName } from './grammar.js'
 export { moonbitGrammar, readMoonbitGrammar } from './content.js'
-export { moonbitLanguage, createMoonbitLanguageRegistration } from './shiki.js'
+export { moonbitLanguage, createMoonbitLanguageRegistration, moonbitTextMateGrammar } from './shiki.js'

package/src/shiki.d.ts

@@ -1,14 +1,19 @@
 import type { moonbitAliases, moonbitGrammarPath, moonbitScopeName } from './grammar.js'
+import type { MoonbitTextMateGrammar } from './textmate.js'
 
 export interface MoonbitLanguageRegistration {
   id: 'moonbit'
-  name: 'MoonBit'
+  name: 'moonbit'
+  displayName: 'MoonBit'
   scopeName: typeof moonbitScopeName
-  aliases: typeof moonbitAliases
+  aliases: readonly ['mbt', 'mbti']
   path: typeof moonbitGrammarPath
-  grammar: string
+  patterns: MoonbitTextMateGrammar['patterns']
+  repository: MoonbitTextMateGrammar['repository']
 }
 
 export declare const moonbitLanguage: Omit<MoonbitLanguageRegistration, 'grammar'>
 
 export declare function createMoonbitLanguageRegistration(): MoonbitLanguageRegistration
+
+export declare const moonbitTextMateGrammar: MoonbitTextMateGrammar

package/src/shiki.js

@@ -1,5 +1,6 @@
 import { moonbitGrammarPath, moonbitScopeName, moonbitAliases } from './grammar.js'
 import { moonbitGrammar } from './content.js'
+import { moonbitTextMateGrammar } from './textmate.js'
 
 export const moonbitLanguage = {
   id: 'moonbit',
@@ -11,7 +12,12 @@ export const moonbitLanguage = {
 
 export function createMoonbitLanguageRegistration() {
   return {
-    ...moonbitLanguage,
-    grammar: moonbitGrammar,
+    ...moonbitTextMateGrammar,
+    id: moonbitLanguage.id,
+    path: moonbitLanguage.path,
+    displayName: moonbitLanguage.name,
+    aliases: moonbitAliases.filter(alias => alias !== 'moonbit'),
   }
 }
+
+export { moonbitTextMateGrammar }

package/src/textmate.d.ts

@@ -0,0 +1,10 @@
+export interface MoonbitTextMateGrammar {
+  name: 'moonbit'
+  scopeName: 'source.moonbit'
+  aliases: readonly ['mbt', 'mbti']
+  patterns: Array<{ include: string }>
+  repository: Record<string, unknown>
+}
+
+export declare const moonbitTextMateGrammar: MoonbitTextMateGrammar
+

package/src/textmate.js

@@ -0,0 +1,131 @@
+export const moonbitTextMateGrammar = {
+  name: 'moonbit',
+  scopeName: 'source.moonbit',
+  aliases: ['mbt', 'mbti'],
+  patterns: [
+    { include: '#comments' },
+    { include: '#strings' },
+    { include: '#numbers' },
+    { include: '#keywords' },
+    { include: '#types' },
+    { include: '#attributes' },
+    { include: '#functions' },
+    { include: '#operators' },
+  ],
+  repository: {
+    comments: {
+      patterns: [
+        {
+          name: 'comment.line.documentation.moonbit',
+          match: '///.*$',
+        },
+        {
+          name: 'comment.line.double-slash.moonbit',
+          match: '//.*$',
+        },
+      ],
+    },
+    strings: {
+      patterns: [
+        {
+          name: 'string.quoted.double.moonbit',
+          begin: '"',
+          end: '"',
+          patterns: [
+            {
+              name: 'constant.character.escape.moonbit',
+              match:
+                '\\\\(?:[nrtb"\\\\]|x[0-9A-Fa-f]{2}|u\\{[0-9A-Fa-f_]{1,6}\\})',
+            },
+          ],
+        },
+        {
+          name: 'string.quoted.single.moonbit',
+          begin: "'",
+          end: "'",
+          patterns: [
+            {
+              name: 'constant.character.escape.moonbit',
+              match:
+                "\\\\(?:[nrtb'\\\\]|x[0-9A-Fa-f]{2}|u\\{[0-9A-Fa-f_]{1,6}\\})",
+            },
+          ],
+        },
+      ],
+    },
+    numbers: {
+      patterns: [
+        {
+          name: 'constant.numeric.float.moonbit',
+          match:
+            '\\b(?:\\d[\\d_]*\\.\\d[\\d_]*|\\d[\\d_]*[eE][+-]?\\d[\\d_]*)\\b',
+        },
+        {
+          name: 'constant.numeric.integer.hex.moonbit',
+          match: '\\b0[xX][0-9A-Fa-f_]+\\b',
+        },
+        {
+          name: 'constant.numeric.integer.moonbit',
+          match: '\\b\\d[\\d_]*\\b',
+        },
+      ],
+    },
+    keywords: {
+      patterns: [
+        {
+          name: 'storage.modifier.moonbit',
+          match: '\\b(?:pub|priv|readonly|extern|mut)\\b',
+        },
+        {
+          name: 'keyword.control.moonbit',
+          match:
+            '\\b(?:if|else|match|lexmatch|guard|for|while|loop|break|continue|return|try|catch|except|raise|noraise|nobreak|using|as|in|is|async|defer)\\b',
+        },
+        {
+          name: 'keyword.declaration.moonbit',
+          match:
+            '\\b(?:fn|fnalias|type!?|typealias|let|letrec|const|enum|extenum|struct|import|trait|traitalias|derive|test|impl|with|recur|suberror|and|where|declare)\\b',
+        },
+      ],
+    },
+    types: {
+      patterns: [
+        {
+          name: 'support.type.builtin.moonbit',
+          match:
+            '\\b(?:Eq|Compare|Hash|Show|Logger|Default|ToJson|FromJson|None|Some|ArrayView|Array|FixedArray|Int16|Int64|Int|UInt16|UInt64|UInt|BigInt|Option|Result|BytesView|Bytes|Bool|Unit|Char|String|Float|Double|Error|Tuple|Hasher|Iter|Iter2|IterResult|Json|Map|Set|StringBuilder|UninitializedArray)\\b',
+        },
+        {
+          name: 'entity.name.type.moonbit',
+          match: '\\b[A-Z][A-Za-z0-9_]*\\b',
+        },
+      ],
+    },
+    attributes: {
+      patterns: [
+        {
+          name: 'variable.annotation.moonbit',
+          match: '#[a-z][A-Za-z0-9_]*',
+        },
+      ],
+    },
+    functions: {
+      patterns: [
+        {
+          name: 'entity.name.function.moonbit',
+          match: '\\b[a-z][A-Za-z0-9_]*(?=\\s*\\()',
+        },
+      ],
+    },
+    operators: {
+      patterns: [
+        {
+          name: 'keyword.operator.moonbit',
+          match:
+            '->|=>|\\|>|==|!=|<=|>=|&&|\\|\\||[-+*/%<>=:;,.{}()\\[\\]]',
+        },
+      ],
+    },
+  },
+}
+