tjs-lang 0.2.0

package/editors/monaco/ajs-monarch.ts

@@ -0,0 +1,225 @@
+/**
+ * Monaco Editor Monarch Tokenizer for AsyncJS
+ *
+ * Usage:
+ * ```typescript
+ * import * as monaco from 'monaco-editor'
+ * import { languageId, languageConfiguration, monarchLanguage } from 'tjs-lang/editors/monaco/ajs-monarch'
+ *
+ * monaco.languages.register({ id: languageId })
+ * monaco.languages.setLanguageConfiguration(languageId, languageConfiguration)
+ * monaco.languages.setMonarchTokensProvider(languageId, monarchLanguage)
+ * ```
+ */
+
+import type * as Monaco from 'monaco-editor'
+import { KEYWORDS, FORBIDDEN_KEYWORDS, TYPE_CONSTRUCTORS } from '../ajs-syntax'
+
+export const languageId = 'ajs'
+
+export const languageConfiguration: Monaco.languages.LanguageConfiguration = {
+  comments: {
+    lineComment: '//',
+    blockComment: ['/*', '*/'],
+  },
+  brackets: [
+    ['{', '}'],
+    ['[', ']'],
+    ['(', ')'],
+  ],
+  autoClosingPairs: [
+    { open: '{', close: '}' },
+    { open: '[', close: ']' },
+    { open: '(', close: ')' },
+    { open: "'", close: "'", notIn: ['string', 'comment'] },
+    { open: '"', close: '"', notIn: ['string', 'comment'] },
+    { open: '`', close: '`', notIn: ['string', 'comment'] },
+  ],
+  surroundingPairs: [
+    { open: '{', close: '}' },
+    { open: '[', close: ']' },
+    { open: '(', close: ')' },
+    { open: "'", close: "'" },
+    { open: '"', close: '"' },
+    { open: '`', close: '`' },
+  ],
+  folding: {
+    markers: {
+      start: /^\s*\/\/\s*#region\b/,
+      end: /^\s*\/\/\s*#endregion\b/,
+    },
+  },
+}
+
+export const monarchLanguage: Monaco.languages.IMonarchLanguage = {
+  defaultToken: 'source',
+  ignoreCase: false,
+
+  // Good parts - standard keywords (from shared definition)
+  keywords: [...KEYWORDS],
+
+  // Bad parts - forbidden in AsyncJS (from shared definition)
+  forbidden: [...FORBIDDEN_KEYWORDS],
+
+  // Built-in type constructors used as factories (from shared definition)
+  typeKeywords: [...TYPE_CONSTRUCTORS],
+
+  operators: [
+    '=',
+    '>',
+    '<',
+    '!',
+    '~',
+    '?',
+    ':',
+    '==',
+    '<=',
+    '>=',
+    '!=',
+    '&&',
+    '||',
+    '++',
+    '--',
+    '+',
+    '-',
+    '*',
+    '/',
+    '&',
+    '|',
+    '^',
+    '%',
+    '<<',
+    '>>',
+    '>>>',
+    '+=',
+    '-=',
+    '*=',
+    '/=',
+    '&=',
+    '|=',
+    '^=',
+    '%=',
+    '<<=',
+    '>>=',
+    '>>>=',
+  ],
+
+  symbols: /[=><!~?:&|+\-*\/\^%]+/,
+
+  escapes:
+    /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+
+  tokenizer: {
+    root: [
+      // Identifiers and keywords
+      [
+        /[a-zA-Z_$][\w$]*/,
+        {
+          cases: {
+            '@forbidden': 'invalid', // Red squiggly for bad parts
+            '@keywords': 'keyword',
+            '@typeKeywords': 'type.identifier',
+            '@default': 'identifier',
+          },
+        },
+      ],
+
+      // Whitespace
+      { include: '@whitespace' },
+
+      // Delimiters and operators
+      [/[{}()\[\]]/, '@brackets'],
+      [
+        /@symbols/,
+        {
+          cases: {
+            '@operators': 'operator',
+            '@default': '',
+          },
+        },
+      ],
+
+      // Numbers
+      [/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
+      [/0[xX][0-9a-fA-F]+/, 'number.hex'],
+      [/\d+/, 'number'],
+
+      // Delimiter: after number because of .\d floats
+      [/[;,.]/, 'delimiter'],
+
+      // Strings
+      [/'/, { token: 'string.quote', bracket: '@open', next: '@stringSingle' }],
+      [/"/, { token: 'string.quote', bracket: '@open', next: '@stringDouble' }],
+      [
+        /`/,
+        {
+          token: 'string.quote',
+          bracket: '@open',
+          next: '@stringBacktick',
+        },
+      ],
+    ],
+
+    stringSingle: [
+      [/[^\\']+/, 'string'],
+      [/@escapes/, 'string.escape'],
+      [/\\./, 'string.escape.invalid'],
+      [/'/, { token: 'string.quote', bracket: '@close', next: '@pop' }],
+    ],
+
+    stringDouble: [
+      [/[^\\"]+/, 'string'],
+      [/@escapes/, 'string.escape'],
+      [/\\./, 'string.escape.invalid'],
+      [/"/, { token: 'string.quote', bracket: '@close', next: '@pop' }],
+    ],
+
+    stringBacktick: [
+      [/[^\\`$]+/, 'string'],
+      [/@escapes/, 'string.escape'],
+      [/\\./, 'string.escape.invalid'],
+      [
+        /\$\{/,
+        {
+          token: 'delimiter.bracket',
+          next: '@stringTemplateExpression',
+        },
+      ],
+      [/`/, { token: 'string.quote', bracket: '@close', next: '@pop' }],
+    ],
+
+    stringTemplateExpression: [
+      [/[^}]+/, 'identifier'],
+      [/\}/, { token: 'delimiter.bracket', next: '@pop' }],
+    ],
+
+    whitespace: [
+      [/[ \t\r\n]+/, 'white'],
+      [/\/\*\*(?!\/)/, 'comment.doc', '@docComment'],
+      [/\/\*/, 'comment', '@comment'],
+      [/\/\/.*$/, 'comment'],
+    ],
+
+    comment: [
+      [/[^\/*]+/, 'comment'],
+      [/\*\//, 'comment', '@pop'],
+      [/[\/*]/, 'comment'],
+    ],
+
+    docComment: [
+      [/@\w+/, 'comment.doc.tag'],
+      [/[^\/*]+/, 'comment.doc'],
+      [/\*\//, 'comment.doc', '@pop'],
+      [/[\/*]/, 'comment.doc'],
+    ],
+  },
+}
+
+/**
+ * Register AsyncJS language with Monaco editor
+ */
+export function registerAjsLanguage(monaco: typeof Monaco): void {
+  monaco.languages.register({ id: languageId })
+  monaco.languages.setLanguageConfiguration(languageId, languageConfiguration)
+  monaco.languages.setMonarchTokensProvider(languageId, monarchLanguage)
+}

package/editors/tjs-syntax.ts

@@ -0,0 +1,115 @@
+/**
+ * TJS (Typed JavaScript) Syntax Definitions
+ *
+ * Extends AsyncJS syntax with:
+ * - test/mock/unsafe keywords
+ * - Return type annotation (-> Type)
+ * - Markdown in non-JSDoc comments
+ */
+
+import {
+  KEYWORDS as AJS_KEYWORDS,
+  FORBIDDEN_KEYWORDS as AJS_FORBIDDEN,
+  TYPE_CONSTRUCTORS as AJS_TYPE_CONSTRUCTORS,
+  OPERATORS as AJS_OPERATORS,
+} from './ajs-syntax'
+
+/**
+ * TJS-specific keywords (in addition to AJS)
+ */
+export const TJS_KEYWORDS = [
+  'test', // inline tests
+  'mock', // test setup blocks
+  'unsafe', // exception-catching blocks
+  'async', // TJS allows async (unlike sandboxed AJS)
+  'await',
+] as const
+
+/**
+ * All TJS keywords
+ */
+export const KEYWORDS = [...AJS_KEYWORDS, ...TJS_KEYWORDS] as const
+
+/**
+ * TJS forbidden keywords (fewer than AJS - TJS is less restrictive)
+ * TJS allows: async/await, throw, import/export
+ */
+export const FORBIDDEN_KEYWORDS = AJS_FORBIDDEN.filter(
+  (k) => !['async', 'await', 'throw', 'import', 'export'].includes(k)
+) as readonly string[]
+
+/**
+ * Type constructors (same as AJS plus TJS-specific)
+ */
+export const TYPE_CONSTRUCTORS = [
+  ...AJS_TYPE_CONSTRUCTORS,
+  'expect', // test assertions
+  'assert', // simple assertions
+] as const
+
+/**
+ * TJS operators (same as AJS plus return type arrow)
+ */
+export const OPERATORS = [...AJS_OPERATORS, '->'] as const
+
+/**
+ * TJS-specific syntax patterns
+ */
+export const TJS_PATTERNS = {
+  // Return type annotation: -> Type
+  returnType: /\)\s*->\s*(\{[^}]+\}|'[^']*'|"[^"]*"|\[[^\]]*\]|\w+)/,
+
+  // Unsafe function marker: function name(! or function name(!
+  unsafeFunction: /function\s+(\w+)\s*\(\s*!/,
+
+  // Test block: test('description') { ... }
+  testBlock: /test\s*\(\s*(['"`])([^'"`]*)\1\s*\)\s*\{/,
+
+  // Mock block: mock { ... }
+  mockBlock: /mock\s*\{/,
+
+  // Unsafe block: unsafe { ... }
+  unsafeBlock: /unsafe\s*\{/,
+
+  // Colon type annotation: name: 'type' or name: 0
+  colonType:
+    /([a-zA-Z_$][a-zA-Z0-9_$]*)\s*:\s*('[^']*'|"[^"]*"|\d+|\{[^}]*\}|\[[^\]]*\]|true|false|null)/,
+}
+
+/**
+ * Markdown elements to highlight in comments
+ * (for non-JSDoc block comments)
+ */
+export const MARKDOWN_PATTERNS = {
+  // Headers: # ## ###
+  header: /^(\s*)(#{1,6})\s+(.*)$/m,
+
+  // Bold: **text** or __text__
+  bold: /(\*\*|__)([^*_]+)\1/,
+
+  // Italic: *text* or _text_
+  italic: /(\*|_)([^*_]+)\1/,
+
+  // Code: `code`
+  inlineCode: /`([^`]+)`/,
+
+  // Links: [text](url)
+  link: /\[([^\]]+)\]\(([^)]+)\)/,
+
+  // Lists: - item or * item or 1. item
+  listItem: /^(\s*)([*\-]|\d+\.)\s+/m,
+}
+
+/**
+ * Questions/Notes:
+ *
+ * Q1: Should markdown highlighting be in all comments or just /* ... *\/?
+ *     Current plan: Only non-JSDoc block comments (/* without **)
+ *
+ * Q2: How deep should markdown parsing go?
+ *     Current: Basic patterns (headers, bold, italic, code, links)
+ *     Could add: code blocks, tables, etc.
+ *
+ * Q3: Should we generate separate TJS grammar files or extend AJS?
+ *     Current plan: Extend - TJS is a superset
+ */

package/editors/vscode/language-configuration.json

@@ -0,0 +1,37 @@
+{
+  "comments": {
+    "lineComment": "//",
+    "blockComment": ["/*", "*/"]
+  },
+  "brackets": [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"]
+  ],
+  "autoClosingPairs": [
+    { "open": "{", "close": "}" },
+    { "open": "[", "close": "]" },
+    { "open": "(", "close": ")" },
+    { "open": "'", "close": "'", "notIn": ["string", "comment"] },
+    { "open": "\"", "close": "\"", "notIn": ["string", "comment"] },
+    { "open": "`", "close": "`", "notIn": ["string", "comment"] }
+  ],
+  "surroundingPairs": [
+    ["{", "}"],
+    ["[", "]"],
+    ["(", ")"],
+    ["'", "'"],
+    ["\"", "\""],
+    ["`", "`"]
+  ],
+  "folding": {
+    "markers": {
+      "start": "^\\s*//\\s*#region\\b",
+      "end": "^\\s*//\\s*#endregion\\b"
+    }
+  },
+  "indentationRules": {
+    "increaseIndentPattern": "^.*\\{[^}]*$",
+    "decreaseIndentPattern": "^\\s*\\}"
+  }
+}

package/editors/vscode/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "tjs-lang-ajs",
+  "displayName": "AsyncJS (tjs-lang)",
+  "description": "Syntax highlighting for AsyncJS - ajs`...` template literals and .ajs files",
+  "version": "0.1.0",
+  "publisher": "tosijs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/tonioloewald/tjs-lang"
+  },
+  "engines": {
+    "vscode": "^1.75.0"
+  },
+  "categories": [
+    "Programming Languages"
+  ],
+  "contributes": {
+    "configurationDefaults": {
+      "editor.tokenColorCustomizations": {
+        "textMateRules": [
+          {
+            "scope": "invalid.illegal.ajs",
+            "settings": {
+              "foreground": "#ff0000",
+              "fontStyle": "bold underline"
+            }
+          }
+        ]
+      }
+    },
+    "languages": [
+      {
+        "id": "ajs",
+        "aliases": [
+          "AsyncJS",
+          "ajs"
+        ],
+        "extensions": [
+          ".ajs"
+        ],
+        "configuration": "./language-configuration.json"
+      }
+    ],
+    "grammars": [
+      {
+        "language": "ajs",
+        "scopeName": "source.ajs",
+        "path": "./syntaxes/ajs.tmLanguage.json"
+      },
+      {
+        "scopeName": "inline.ajs.injection",
+        "path": "./syntaxes/ajs-injection.tmLanguage.json",
+        "injectTo": [
+          "source.js",
+          "source.ts",
+          "source.tsx",
+          "source.jsx"
+        ],
+        "embeddedLanguages": {
+          "meta.embedded.block.ajs": "javascript"
+        }
+      }
+    ]
+  }
+}

package/editors/vscode/syntaxes/ajs-injection.tmLanguage.json

@@ -0,0 +1,107 @@
+{
+  "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+  "name": "AsyncJS Injection",
+  "scopeName": "inline.ajs.injection",
+  "injectionSelector": "L:source.js, L:source.ts, L:source.tsx, L:source.jsx",
+  "patterns": [
+    {
+      "begin": "(ajs|transpile)\\s*(`)",
+      "beginCaptures": {
+        "1": { "name": "entity.name.function.tagged-template.js" },
+        "2": { "name": "punctuation.definition.string.template.begin.js" }
+      },
+      "end": "(`)",
+      "endCaptures": {
+        "1": { "name": "punctuation.definition.string.template.end.js" }
+      },
+      "contentName": "meta.embedded.block.ajs",
+      "patterns": [
+        { "include": "#template-substitution" },
+        { "include": "#ajs-content" }
+      ]
+    }
+  ],
+  "repository": {
+    "template-substitution": {
+      "begin": "(\\$\\{)",
+      "beginCaptures": {
+        "1": { "name": "punctuation.definition.template-expression.begin.js" }
+      },
+      "end": "(\\})",
+      "endCaptures": {
+        "1": { "name": "punctuation.definition.template-expression.end.js" }
+      },
+      "contentName": "meta.template.expression.js",
+      "patterns": [{ "include": "source.ts" }]
+    },
+    "ajs-content": {
+      "patterns": [
+        { "include": "#forbidden" },
+        { "include": "#function-def" },
+        { "include": "#keywords" },
+        { "include": "#strings" },
+        { "include": "#numbers" },
+        { "include": "#comments" },
+        { "include": "#operators" }
+      ]
+    },
+    "forbidden": {
+      "patterns": [
+        {
+          "match": "\\b(new|class|async|await|var|this|super|extends|implements|interface|type|yield|import|export|require)\\b",
+          "name": "invalid.illegal.ajs"
+        },
+        {
+          "comment": "Ternary operator ? - not supported (but allow ?. optional chaining)",
+          "match": "\\?(?![.:])",
+          "name": "invalid.illegal.ajs"
+        }
+      ]
+    },
+    "function-def": {
+      "match": "\\b(function)\\s+([a-zA-Z_$][a-zA-Z0-9_$]*)",
+      "captures": {
+        "1": { "name": "storage.type.function.js" },
+        "2": { "name": "entity.name.function.js" }
+      }
+    },
+    "keywords": {
+      "match": "\\b(function|return|if|else|while|for|of|in|try|catch|finally|throw|let|const|true|false|null)\\b",
+      "name": "keyword.control.js"
+    },
+    "strings": {
+      "patterns": [
+        {
+          "begin": "'",
+          "end": "'",
+          "name": "string.quoted.single.js",
+          "patterns": [
+            { "match": "\\\\.", "name": "constant.character.escape.js" }
+          ]
+        },
+        {
+          "begin": "\"",
+          "end": "\"",
+          "name": "string.quoted.double.js",
+          "patterns": [
+            { "match": "\\\\.", "name": "constant.character.escape.js" }
+          ]
+        }
+      ]
+    },
+    "numbers": {
+      "match": "\\b\\d+(\\.\\d+)?\\b",
+      "name": "constant.numeric.js"
+    },
+    "comments": {
+      "patterns": [
+        { "match": "//.*$", "name": "comment.line.double-slash.js" },
+        { "begin": "/\\*", "end": "\\*/", "name": "comment.block.js" }
+      ]
+    },
+    "operators": {
+      "match": "=>|&&|\\|\\||===?|!==?|>=?|<=?|[+\\-*/%=]",
+      "name": "keyword.operator.js"
+    }
+  }
+}