@cratis/screenplay-language 0.1.0

package/sub-languages/projection/language.ts

@@ -0,0 +1,193 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import type { languages } from 'monaco-editor';
+
+export const languageId = 'pdl';
+
+// Keywords for the Projection Declaration Language
+const KEYWORDS = [
+    'projection',
+    'sequence',
+    'all',
+    'every',
+    'on',
+    'from',
+    'key',
+    'parent',
+    'join',
+    'automap',
+    'no',
+    'children',
+    'nested',
+    'identified',
+    'by',
+    'add',
+    'subtract',
+    'remove',
+    'via',
+    'with',
+    'default',
+    'increment',
+    'decrement',
+    'count',
+    'set',
+    'unset',
+    'clear',
+    'events',
+    'id',
+    'exclude',
+] as const;
+
+// Built-in expressions and functions
+const BUILTINS = [
+    '$eventSourceId',
+    '$causedBy',
+    '$occurred',
+    '$namespace',
+    '$eventContext',
+] as const;
+
+// Operators
+const OPERATORS = ['=', '+=', '-=', '=>', '.'];
+
+export const configuration: languages.LanguageConfiguration = {
+    comments: {
+        lineComment: '#',
+    },
+    brackets: [
+        ['{', '}'],
+        ['[', ']'],
+        ['(', ')'],
+    ],
+    autoClosingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+        { open: '`', close: '`' },
+    ],
+    surroundingPairs: [
+        { open: '{', close: '}' },
+        { open: '[', close: ']' },
+        { open: '(', close: ')' },
+        { open: '"', close: '"' },
+        { open: "'", close: "'" },
+        { open: '`', close: '`' },
+    ],
+    indentationRules: {
+        increaseIndentPattern: /^.*(:|\bon\b|\ball\b|\bevery\b|\bchildren\b|\bnested\b|\bparent\b)\s*$/,
+        decreaseIndentPattern: /^.*\}.*$/,
+    },
+    folding: {
+        offSide: true,
+        markers: {
+            start: /^\s*(projection|all|every|on|children|nested|parent)/,
+            end: /^\s*$/,
+        },
+    },
+    wordPattern: /@?[a-zA-Z_$][\w$-]*/,
+};
+
+export const monarchLanguage: languages.IMonarchLanguage = {
+    defaultToken: '',
+    tokenPostfix: '.pdl',
+
+    keywords: KEYWORDS,
+    builtins: BUILTINS,
+    operators: OPERATORS,
+
+    // Symbols
+    symbols: /[=><!~?:&|+\-*/^%]+/,
+    escapes: /\\(?:[abfnrtv\\"']|x[0-9A-Fa-f]{1,4}|u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8})/,
+
+    tokenizer: {
+        root: [
+            // Whitespace
+            { include: '@whitespace' },
+
+            // Template strings with ${...} interpolation
+            [/`/, { token: 'string.template', next: '@templateString' }],
+
+            // Escaped identifiers (@ prefix allows using keywords as identifiers)
+            [/@[a-zA-Z_$][\w$]*/, 'identifier.escape'],
+
+            // Check for uppercase keywords (error case - keywords must be lowercase)
+            [
+                /[A-Z][a-zA-Z_$][\w$]*/,
+                {
+                    cases: {
+                        '@keywords': 'invalid',
+                        '@default': 'identifier',
+                    },
+                },
+            ],
+
+            // Identifiers and keywords (lowercase only for keywords)
+            [
+                /[a-z_$][\w$]*/,
+                {
+                    cases: {
+                        '@keywords': 'keyword',
+                        '@builtins': 'variable.predefined',
+                        '@default': 'identifier',
+                    },
+                },
+            ],
+
+            // Delimiters and operators
+            [/[{}()[\]]/, '@brackets'],
+            [/=>/, 'operator.arrow'],
+            [
+                /@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
+            [/"([^"\\]|\\.)*$/, 'string.invalid'],
+            [/"/, { token: 'string.quote', next: '@string' }],
+        ],
+
+        whitespace: [
+            [/[ \t\r\n]+/, ''],
+            [/#.*$/, 'comment'],
+        ],
+
+        // Template string state
+        templateString: [
+            [/\$\{/, { token: 'delimiter.bracket', next: '@templateExpression' }],
+            [/[^\\`$]+/, 'string.template'],
+            [/@escapes/, 'string.template.escape'],
+            [/\\./, 'string.template.escape.invalid'],
+            [/`/, { token: 'string.template', next: '@pop' }],
+        ],
+
+        // Template expression inside ${}
+        templateExpression: [
+            [/\}/, { token: 'delimiter.bracket', next: '@pop' }],
+            { include: '@root' },
+        ],
+
+        // Regular string state
+        string: [
+            [/[^\\"]+/, 'string'],
+            [/@escapes/, 'string.escape'],
+            [/\\./, 'string.escape.invalid'],
+            [/"/, { token: 'string.quote', next: '@pop' }],
+        ],
+    },
+};

package/symbols.ts

@@ -0,0 +1,161 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import { fenceMap, indentOf } from './document-context';
+
+export interface PropertySymbol {
+    name: string;
+    type: string;
+}
+
+export interface ConceptSymbol {
+    name: string;
+    primitive: string;
+    attributes: string[];
+    enumValues: string[];
+    line: number;
+}
+
+export interface PolicySymbol {
+    name: string;
+    requires: string[];
+    line: number;
+}
+
+export interface EventSymbol {
+    name: string;
+    properties: PropertySymbol[];
+    line: number;
+}
+
+export interface NamedSymbol {
+    name: string;
+    line: number;
+}
+
+export interface QuerySymbol extends NamedSymbol {
+    returnType: string;
+}
+
+export interface ImportSymbol {
+    qualifiedName: string;
+    shortName: string;
+    line: number;
+}
+
+export interface DocumentSymbols {
+    imports: ImportSymbol[];
+    concepts: ConceptSymbol[];
+    policies: PolicySymbol[];
+    events: EventSymbol[];
+    commands: NamedSymbol[];
+    queries: QuerySymbol[];
+    screens: NamedSymbol[];
+}
+
+const conceptPattern = /^concept\s+(\w+)\s*:\s*(\w+)((?:\s+@\w+)*)\s*$/;
+const propertyPattern = /^\s*([a-z_]\w*)\s+([\w.]+(?:\[\])?\??)\s*$/;
+
+function collectBody(lines: string[], fences: boolean[], start: number, indent: number): number[] {
+    const body: number[] = [];
+    for (let index = start + 1; index < lines.length; index++) {
+        if (fences[index]) {
+            body.push(index);
+            continue;
+        }
+        const line = lines[index];
+        if (line.trim().length === 0) continue;
+        if (indentOf(line) <= indent) break;
+        body.push(index);
+    }
+    return body;
+}
+
+export function scanDocument(lines: string[]): DocumentSymbols {
+    const symbols: DocumentSymbols = {
+        imports: [],
+        concepts: [],
+        policies: [],
+        events: [],
+        commands: [],
+        queries: [],
+        screens: [],
+    };
+    const fences = fenceMap(lines);
+
+    for (let index = 0; index < lines.length; index++) {
+        if (fences[index]) continue;
+        const line = lines[index];
+        const trimmed = line.trim();
+        const indent = indentOf(line);
+
+        const importMatch = trimmed.match(/^import\s+([\w.]+)\s*$/);
+        if (importMatch && indent === 0) {
+            const qualifiedName = importMatch[1];
+            const shortName = qualifiedName.split('.').pop() ?? qualifiedName;
+            symbols.imports.push({ qualifiedName, shortName, line: index });
+            continue;
+        }
+
+        const conceptMatch = trimmed.match(conceptPattern);
+        if (conceptMatch) {
+            const enumValues =
+                conceptMatch[2] === 'Enum'
+                    ? collectBody(lines, fences, index, indent).map((i) => lines[i].trim())
+                    : [];
+            symbols.concepts.push({
+                name: conceptMatch[1],
+                primitive: conceptMatch[2],
+                attributes: conceptMatch[3].trim().split(/\s+/).filter(Boolean),
+                enumValues,
+                line: index,
+            });
+            continue;
+        }
+
+        const policyMatch = trimmed.match(/^policy\s+(\w+)\s*$/);
+        if (policyMatch) {
+            const requires = collectBody(lines, fences, index, indent)
+                .filter((i) => !fences[i])
+                .map((i) => lines[i].trim());
+            symbols.policies.push({ name: policyMatch[1], requires, line: index });
+            continue;
+        }
+
+        const eventMatch = trimmed.match(/^event\s+(\w+)\s*$/);
+        if (eventMatch) {
+            const properties = collectBody(lines, fences, index, indent)
+                .map((i) => lines[i].match(propertyPattern))
+                .filter((match): match is RegExpMatchArray => match !== null)
+                .map((match) => ({ name: match[1], type: match[2] }));
+            symbols.events.push({ name: eventMatch[1], properties, line: index });
+            continue;
+        }
+
+        const commandMatch = trimmed.match(/^command\s+(\w+)\s*$/);
+        if (commandMatch) {
+            symbols.commands.push({ name: commandMatch[1], line: index });
+            continue;
+        }
+
+        const queryMatch = trimmed.match(/^query\s+(\w+)\s*=>\s*([\w[\]]+)\s*$/);
+        if (queryMatch) {
+            symbols.queries.push({ name: queryMatch[1], returnType: queryMatch[2], line: index });
+            continue;
+        }
+
+        const screenMatch = trimmed.match(/^screen\s+(\w+)\s*$/);
+        if (screenMatch) {
+            symbols.screens.push({ name: screenMatch[1], line: index });
+        }
+    }
+
+    return symbols;
+}
+
+export function knownEventNames(symbols: DocumentSymbols): string[] {
+    return [
+        ...symbols.events.map((event) => event.name),
+        ...symbols.imports.map((imported) => imported.shortName),
+    ];
+}

package/themes/screenplay-dark.ts

@@ -0,0 +1,32 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import type { editor } from 'monaco-editor';
+
+export const screenplayDarkThemeName = 'screenplay-dark';
+
+export const screenplayDark: editor.IStandaloneThemeData = {
+    base: 'vs-dark',
+    inherit: true,
+    rules: [
+        { token: 'keyword.play', foreground: 'C586C0' },
+        { token: 'keyword.tag.play', foreground: '569CD6', fontStyle: 'italic' },
+        { token: 'keyword.type.play', foreground: '4FC1FF', fontStyle: 'bold' },
+        { token: 'type.play', foreground: '4EC9B0' },
+        { token: 'type.identifier.play', foreground: '4EC9B0' },
+        { token: 'identifier.play', foreground: '9CDCFE' },
+        { token: 'annotation.play', foreground: 'DCDCAA' },
+        { token: 'variable.predefined.play', foreground: 'D7BA7D' },
+        { token: 'string.play', foreground: 'CE9178' },
+        { token: 'string.invalid.play', foreground: 'F44747' },
+        { token: 'string.quote.play', foreground: '6A9955' },
+        { token: 'number.play', foreground: 'B5CEA8' },
+        { token: 'number.float.play', foreground: 'B5CEA8' },
+        { token: 'comment.play', foreground: '6A9955', fontStyle: 'italic' },
+        { token: 'operator.play', foreground: 'D4D4D4' },
+        { token: 'delimiter.play', foreground: 'CCCCCC' },
+    ],
+    colors: {
+        'editor.background': '#1E1E1E',
+    },
+};

package/themes/screenplay-light.ts

@@ -0,0 +1,32 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import type { editor } from 'monaco-editor';
+
+export const screenplayLightThemeName = 'screenplay-light';
+
+export const screenplayLight: editor.IStandaloneThemeData = {
+    base: 'vs',
+    inherit: true,
+    rules: [
+        { token: 'keyword.play', foreground: 'AF00DB' },
+        { token: 'keyword.tag.play', foreground: '0000FF', fontStyle: 'italic' },
+        { token: 'keyword.type.play', foreground: '0070C1', fontStyle: 'bold' },
+        { token: 'type.play', foreground: '267F99' },
+        { token: 'type.identifier.play', foreground: '267F99' },
+        { token: 'identifier.play', foreground: '001080' },
+        { token: 'annotation.play', foreground: '795E26' },
+        { token: 'variable.predefined.play', foreground: 'B45309' },
+        { token: 'string.play', foreground: 'A31515' },
+        { token: 'string.invalid.play', foreground: 'CD3131' },
+        { token: 'string.quote.play', foreground: '008000' },
+        { token: 'number.play', foreground: '098658' },
+        { token: 'number.float.play', foreground: '098658' },
+        { token: 'comment.play', foreground: '008000', fontStyle: 'italic' },
+        { token: 'operator.play', foreground: '000000' },
+        { token: 'delimiter.play', foreground: '000000' },
+    ],
+    colors: {
+        'editor.background': '#FFFFFF',
+    },
+};

package/tokens.ts

@@ -0,0 +1,145 @@
+// Copyright (c) Cratis. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+import type { languages } from 'monaco-editor';
+import {
+    clauseKeywords,
+    codeBlockTags,
+    constructKeywords,
+    primitiveTypes,
+    sliceTypes,
+} from './language';
+import { MonarchTokenRules, SubLanguage } from './sub-language-registry';
+
+// Maps a Screenplay inline code tag to the Monaco language id used for embedded highlighting.
+const embeddedLanguages: Record<string, string> = {
+    csharp: 'csharp',
+    typescript: 'typescript',
+    react: 'typescript',
+    html: 'html',
+};
+
+function subLanguageState(keyword: string): string {
+    return `subLanguage_${keyword}`;
+}
+
+// A construct keyword at the start of a line ends any indented sub-language block.
+function subLanguageExitRule(subLanguages: SubLanguage[]): MonarchTokenRules[number] {
+    const exitKeywords = [...constructKeywords, ...subLanguages.map((subLanguage) => subLanguage.keyword)];
+    return [
+        new RegExp(`^\\s*(?:${exitKeywords.join('|')})\\b`),
+        { token: '@rematch', next: '@pop' },
+    ];
+}
+
+// Shared across the composite `.play` tokenizer and every standalone sub-language tokenizer
+// (comments, `$`-prefixed context variables, strings, numbers, operators, delimiters, whitespace).
+export const commonTokenRules: MonarchTokenRules = [
+    [/\/\/.*$/, 'comment'],
+    [/\$(?:context|eventContext|eventSourceId|causedBy)(?:\.\w+)*/, 'variable.predefined'],
+    [/\$(?:env|secrets|strings)\.[\w.]+/, 'variable.predefined'],
+    [/\$\.[\w.]*/, 'variable.predefined'],
+    [/"(?:[^"\\]|\\.)*"/, 'string'],
+    [/"(?:[^"\\]|\\.)*$/, 'string.invalid'],
+    [/\d+(?:ms|s|m|h|d)\b/, 'number'],
+    [/-?\d+\.\d+/, 'number.float'],
+    [/-?\d+/, 'number'],
+    [/=>|==|!=|>=|<=|[><=:?]/, 'operator'],
+    [/[[\](),.]/, 'delimiter'],
+    [/\s+/, 'white'],
+];
+
+export function createTokensProvider(subLanguages: SubLanguage[]): languages.IMonarchLanguage {
+    const tokenizer: Record<string, MonarchTokenRules> = {
+        root: [
+            // Inline code block tags at end of line open an embedded code block.
+            ...codeBlockTags.map(
+                (tag): MonarchTokenRules[number] => [
+                    new RegExp(`\\b${tag}\\b(?=\\s*$)`),
+                    { token: 'keyword.tag', next: `@codeBlockPending.${embeddedLanguages[tag]}` },
+                ],
+            ),
+            // Sub-language constructs switch to the registered sub-language's token rules.
+            ...subLanguages.map(
+                (subLanguage): MonarchTokenRules[number] => [
+                    new RegExp(`\\b${subLanguage.keyword}\\b`),
+                    { token: 'keyword', next: `@${subLanguageState(subLanguage.keyword)}` },
+                ],
+            ),
+            // A bare description keyword at end of line opens a fenced plain-text block.
+            [/\bdescription\b(?=\s*$)/, { token: 'keyword', next: '@descriptionBlockPending' }],
+            [/\brow-click\b/, 'keyword'],
+            [/@\w+/, 'annotation'],
+            [
+                /[A-Z]\w*/,
+                {
+                    cases: {
+                        '@sliceTypes': 'keyword.type',
+                        '@primitiveTypes': 'type',
+                        '@default': 'type.identifier',
+                    },
+                },
+            ],
+            [
+                /[a-z_]\w*/,
+                {
+                    cases: {
+                        '@keywords': 'keyword',
+                        '@default': 'identifier',
+                    },
+                },
+            ],
+            { include: '@common' },
+        ],
+
+        common: commonTokenRules,
+
+        // After a code tag, the only thing allowed before the opening fence is whitespace.
+        codeBlockPending: [
+            [
+                /^\s*```\s*$/,
+                { token: 'string.quote', switchTo: '@codeBlock.$S2', nextEmbedded: '$S2' },
+            ],
+            [/^\s*[^\s`].*$/, { token: '@rematch', next: '@pop' }],
+            [/\s+/, 'white'],
+        ],
+
+        codeBlock: [
+            [/^\s*```\s*$/, { token: 'string.quote', next: '@pop', nextEmbedded: '@pop' }],
+            [/[^`]+/, ''],
+            [/`/, ''],
+        ],
+
+        // After a bare description, the only thing allowed before the opening fence is whitespace.
+        descriptionBlockPending: [
+            [/^\s*```\s*$/, { token: 'string.quote', switchTo: '@descriptionBlock' }],
+            [/^\s*[^\s`].*$/, { token: '@rematch', next: '@pop' }],
+            [/\s+/, 'white'],
+        ],
+
+        descriptionBlock: [
+            [/^\s*```\s*$/, { token: 'string.quote', next: '@pop' }],
+            [/.+/, 'string'],
+        ],
+    };
+
+    for (const subLanguage of subLanguages) {
+        tokenizer[subLanguageState(subLanguage.keyword)] = [
+            subLanguageExitRule(subLanguages),
+            ...subLanguage.tokens,
+            { include: '@common' },
+            [/[A-Z]\w*/, 'type.identifier'],
+            [/[a-z_]\w*/, 'identifier'],
+        ];
+    }
+
+    return {
+        defaultToken: '',
+        tokenPostfix: '.play',
+        ignoreCase: false,
+        keywords: [...constructKeywords, ...clauseKeywords, ...codeBlockTags],
+        sliceTypes,
+        primitiveTypes,
+        tokenizer,
+    } as languages.IMonarchLanguage;
+}