@cratis/screenplay-language 4.51.0 → 4.53.0

package/sub-languages/projection/language.ts

@@ -1,193 +0,0 @@
-// 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',
-    'variant',
-    'enters',
-] as const;
-
-// Built-in expressions and functions
-const BUILTINS = [
-    '$eventSourceId',
-    '$causedBy',
-    '$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|\bvariant\b)\s*$/,
-        decreaseIndentPattern: /^.*\}.*$/,
-    },
-    folding: {
-        offSide: true,
-        markers: {
-            start: /^\s*(projection|all|every|on|children|nested|parent|variant)/,
-            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

@@ -1,374 +0,0 @@
-// 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';
-import { eventAnalysisSource } from './event-analysis-source';
-import { clauseKeywords } from './language';
-import { ProductionSymbol } from './ProductionSymbol';
-
-export interface PropertySymbol {
-    name: string;
-    type: string;
-    isIdentifier: boolean;
-    line: number;
-}
-
-export interface ConceptSymbol {
-    name: string;
-    primitive: string;
-    attributes: string[];
-    attributeReasons: Record<string, string>;
-    enumValues: string[];
-    line: number;
-}
-
-export interface TypeSymbol {
-    name: string;
-    properties: PropertySymbol[];
-    line: number;
-}
-
-export interface PolicySymbol {
-    name: string;
-    requires: string[];
-    line: number;
-}
-
-export interface EventSymbol {
-    name: string;
-    generation?: number;
-    inline?: boolean;
-    properties: PropertySymbol[];
-    line: number;
-}
-
-export interface CommandSymbol extends NamedSymbol {
-    properties: PropertySymbol[];
-    reads?: ReadSymbol[];
-    produces?: ProductionSymbol[];
-    productionHeaders?: number[];
-}
-
-export interface ReadSymbol {
-    view: string;
-    alias?: string;
-    by?: string;
-    line: number;
-}
-
-export interface NamedSymbol {
-    name: string;
-    line: number;
-}
-
-export interface QuerySymbol extends NamedSymbol {
-    returnType: string;
-    parameters: PropertySymbol[];
-}
-
-export interface ImportSymbol {
-    qualifiedName: string;
-    shortName: string;
-    line: number;
-}
-
-export interface DocumentSymbols {
-    imports: ImportSymbol[];
-    concepts: ConceptSymbol[];
-    types: TypeSymbol[];
-    policies: PolicySymbol[];
-    events: EventSymbol[];
-    commands: CommandSymbol[];
-    queries: QuerySymbol[];
-    screens: NamedSymbol[];
-    triggers: NamedSymbol[];
-}
-
-const conceptPattern = /^concept\s+(\w+)\s*:\s*(\w+)((?:\s+@\w+)*)\s*$/;
-const propertyPattern = /^\s*(@?[a-z_]\w*)\s+([\w.]+(?:\[\])?\??)(\s+identifier)?\s*$/;
-const attributeReasonPattern = /^([a-z_]\w*)\s+reason\s+"((?:[^"\\]|\\.)*)"\s*$/;
-const readPattern = /^\s*reads\s+([A-Z]\w*)(?:\s+as\s+([a-z_]\w*))?(?:\s+by\s+([a-z_]\w*))?\s*$/;
-const commandReserved = ['authorize', 'produces', 'reads'];
-// AuthorizeParser's continuation pattern, including the compiler's Unicode word characters.
-const authorizationContinuation = /^(?:(?:or|and)\s+)?[A-Za-z_(][\p{L}\p{Mn}\p{Nd}\p{Pc}\s()]*$/u;
-const eventReserved = clauseKeywords.filter(keyword => !['id', 'description', 'documentation'].includes(keyword));
-const queryParameterPattern =
-    /^\s*(?:by|filter)\s+([a-z_]\w*)\s+([\w.]+(?:\[\])?\??)(?:\s+from\s+.+)?\s*$/;
-
-// Property-shaped clauses depend on their owner. Commands reserve only authorize,
-// produces and reads; bare directives such as description and handler can be properties.
-// The @ escape always denotes a property, and 'as' keeps its established property meaning.
-function propertiesIn(lines: string[], body: number[], reserved: readonly string[]): PropertySymbol[] {
-    return body
-        .map((index) => ({ index, match: lines[index].match(propertyPattern) }))
-        .filter((entry): entry is { index: number; match: RegExpMatchArray } => entry.match !== null)
-        .filter(({ match }) => match[1].startsWith('@') || match[1] === 'as' || !reserved.includes(match[1]))
-        .map(({ index, match }) => ({
-            name: match[1].replace(/^@/, ''),
-            type: match[2],
-            isIdentifier: match[3] !== undefined,
-            line: index,
-        }));
-}
-
-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]) {
-            continue;
-        }
-        const line = lines[index];
-        if (line.trim().length === 0) continue;
-        if (indentOf(line) <= indent) break;
-        body.push(index);
-    }
-    return body;
-}
-
-// Event/production parsers accept every greater indent, not just the smallest child indent.
-// Command block directives own their nested lines; properties do not. Fenced prose is never syntax.
-export function directBody(lines: string[], fences: boolean[], start: number, indent: number): number[] {
-    const body = collectBody(lines, fences, start, indent).filter(index => !fences[index] && !/^\s*(?:\/\/|#)/.test(lines[index]));
-    if (!/^\s*command\b/.test(lines[start])) return body;
-    let blockIndent: number | undefined;
-    let authorization = false;
-    return body.filter(index => {
-        const childIndent = indentOf(lines[index]);
-        const text = lines[index].trim();
-        // AuthorizeParser owns only consecutive deeper lines with requirement shape.
-        // Unlike opaque blocks, a nonmatching line returns control to CommandParser.
-        if (blockIndent !== undefined && childIndent > blockIndent &&
-            (!authorization || authorizationContinuation.test(text))) return false;
-        const property = text !== 'validate csharp' && propertiesIn(lines, [index], commandReserved).length > 0;
-        // Description consumes only a quoted value or a fence (already excluded above).
-        const leaf = property || /^description(?:\s|$)/.test(text);
-        blockIndent = leaf ? undefined : childIndent;
-        authorization = /^authorize(?:\s|$)/.test(text);
-        return true;
-    });
-}
-
-export function scanDocument(lines: string[]): DocumentSymbols {
-    const symbols: DocumentSymbols = {
-        imports: [],
-        concepts: [],
-        types: [],
-        policies: [],
-        events: [],
-        commands: [],
-        queries: [],
-        screens: [],
-        triggers: [],
-    };
-    // One normalization pass for every declaration, including comments on fence openers.
-    lines = eventAnalysisSource(lines);
-    const fences = fenceMap(lines);
-    const eventLines = lines;
-    const eventFences = fences;
-    // Typed inline mappings share property syntax once their source expression is removed.
-    // Do this once, never once per inline event.
-    const eventPropertyLines = lines.map(line => line.replace(/\s*=(?!=|>).*/, ''));
-
-    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 = eventLines[index].trim().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 body = collectBody(lines, fences, index, indent).map((i) => lines[i].trim());
-            const attributeReasons: Record<string, string> = {};
-            for (const line of body) {
-                const reason = line.match(attributeReasonPattern);
-                if (reason && attributeReasons[reason[1]] === undefined) {
-                    attributeReasons[reason[1]] = reason[2];
-                }
-            }
-            const enumValues =
-                conceptMatch[2] === 'Enum'
-                    ? body.filter((line) => !attributeReasonPattern.test(line))
-                    : [];
-            symbols.concepts.push({
-                name: conceptMatch[1],
-                primitive: conceptMatch[2],
-                attributes: conceptMatch[3].trim().split(/\s+/).filter(Boolean),
-                attributeReasons,
-                enumValues,
-                line: index,
-            });
-            continue;
-        }
-
-        const typeMatch = trimmed.match(/^type\s+(\w+)\s*$/);
-        if (typeMatch) {
-            symbols.types.push({
-                name: typeMatch[1],
-                properties: propertiesIn(lines, collectBody(lines, fences, index, indent), clauseKeywords),
-                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 = eventLines[index].trim().match(/^(?:produces\s+)?event\s+(\w+)(?:\s+generation\s+(\d+))?\s*$/);
-        if (eventMatch) {
-            symbols.events.push({
-                name: eventMatch[1],
-                ...(eventMatch[2] ? { generation: Number(eventMatch[2]) } : {}),
-                inline: trimmed.startsWith('produces '),
-                properties: propertiesIn(trimmed.startsWith('produces ') ? eventPropertyLines : eventLines,
-                    directBody(eventLines, eventFences, index, indent), eventReserved),
-                line: index,
-            });
-            continue;
-        }
-
-        const commandMatch = eventLines[index].trim().match(/^command\s+(\w+)\s*$/);
-        if (commandMatch) {
-            // A command property is a leaf, not an indentation owner. Share the parser-shaped
-            // body with properties, productions, advice and destination hints.
-            const body = directBody(lines, fences, index, indent);
-            const productionHeaders = body.filter(line => /^\s*produces\b/.test(lines[line]));
-            symbols.commands.push({
-                name: commandMatch[1],
-                properties: propertiesIn(lines, body.filter(line => lines[line].trim() !== 'validate csharp'), commandReserved),
-                productionHeaders,
-                produces: productionHeaders.flatMap(line => {
-                    const header = eventLines[line].trim();
-                    const inline = /^produces\s+event\b/.test(header);
-                    const conditional = /^produces\s+when\b/.test(header);
-                    const eventLine = conditional ? directBody(eventLines, eventFences, line, indentOf(eventLines[line]))[0] : line;
-                    if (eventLine === undefined) return [];
-                    const name = conditional ? eventLines[eventLine].trim() : header.match(inline ? /^produces\s+event\s+([A-Za-z_]\w*)(?:\s+generation\s+\d+)?\s*$/ : /^produces\s+([A-Z]\w*)\s*$/)?.[1];
-                    if (name === undefined || !/^[A-Za-z_]\w*$/.test(name)) return [];
-                    const children = directBody(eventLines, eventFences, eventLine, indentOf(eventLines[eventLine]));
-                    const targets = children.map(index => eventLines[index].trim().match(/^for(?:\s+(.*))?$/)).filter(match => match !== null);
-                    // Empty or repeated targets are uncertain, not implicit destinations.
-                    const target = targets.length === 0 ? undefined : targets.length === 1 ? targets[0][1] ?? '' : '';
-                    const mappings = children.flatMap(index => {
-                        const match = eventLines[index].trim().match(inline ? /^(@?[a-z_]\w*)\s+[\w.[\]?]+\s*=(?!=|>)\s*(.+)$/ : /^(@?[\w.]+)\s*=(?!=|>)\s*(.+)$/);
-                        return match === null ? [] : [{ name: match[1].replace(/^@/, ''), source: match[2], line: index }];
-                    });
-                    return [{ name, inline, conditional, line, target, mappings }];
-                }),
-                reads: body.filter((line) => !fences[line])
-                    .map((line) => ({ line, match: lines[line].match(readPattern) }))
-                    .filter((entry): entry is { line: number; match: RegExpMatchArray } => entry.match !== null)
-                    .map(({ line, match }) => ({
-                        view: match[1],
-                        ...(match[2] ? { alias: match[2] } : {}),
-                        ...(match[3] ? { by: match[3] } : {}),
-                        line,
-                    })),
-                line: index,
-            });
-            continue;
-        }
-
-        // The return type shape is the compiler's, dots and all - QueryParser's
-        // ^query\s+([A-Za-z_]\w*)\s*=>\s*(observable\s+)?([\w.]+(?:\[\])?\??)$. A narrower one here
-        // silently drops the query from the symbol table, and with it every check and completion that
-        // reads from it.
-        const queryMatch = trimmed.match(/^query\s+(\w+)\s*=>\s*(?:observable\s+)?([\w.]+(?:\[\])?\??)\s*$/);
-        if (queryMatch) {
-            // The return type names a read model, which no construct declares — only the
-            // 'by' and 'filter' parameters resolve against the document's own types.
-            const parameters = collectBody(lines, fences, index, indent)
-                .map((i) => ({ index: i, match: lines[i].match(queryParameterPattern) }))
-                .filter(
-                    (entry): entry is { index: number; match: RegExpMatchArray } =>
-                        entry.match !== null,
-                )
-                .map(({ index: line, match }) => ({
-                    name: match[1],
-                    type: match[2],
-                    isIdentifier: false,
-                    line,
-                }));
-            symbols.queries.push({
-                name: queryMatch[1],
-                returnType: queryMatch[2],
-                parameters,
-                line: index,
-            });
-            continue;
-        }
-
-        const screenMatch = trimmed.match(/^screen\s+(\w+)\s*$/);
-        if (screenMatch) {
-            symbols.screens.push({ name: screenMatch[1], line: index });
-            continue;
-        }
-
-        const triggerMatch = trimmed.match(/^trigger\s+(\w+)\s*$/);
-        if (triggerMatch && indent === 0) {
-            symbols.triggers.push({ name: triggerMatch[1], line: index });
-        }
-    }
-
-    return symbols;
-}
-
-// The symbols of several documents as one - what an application spread over files declares. Lines refer to
-// the document each symbol came from, so the result names things; it does not locate them.
-export function mergeSymbols(...documents: DocumentSymbols[]): DocumentSymbols {
-    return {
-        imports: documents.flatMap((document) => document.imports),
-        concepts: documents.flatMap((document) => document.concepts),
-        types: documents.flatMap((document) => document.types),
-        policies: documents.flatMap((document) => document.policies),
-        events: documents.flatMap((document) => document.events),
-        commands: documents.flatMap((document) => document.commands),
-        queries: documents.flatMap((document) => document.queries),
-        screens: documents.flatMap((document) => document.screens),
-        triggers: documents.flatMap((document) => document.triggers),
-    };
-}
-
-export function knownEventNames(symbols: DocumentSymbols): string[] {
-    return [
-        ...symbols.events.map((event) => event.name),
-        ...symbols.imports.map((imported) => imported.shortName),
-    ];
-}
-
-// The built-in host signals, which have no declaration to scan for because every application has them.
-export const builtInTriggerNames = ['Startup', 'Shutdown'];
-
-// What a reaction's `when` may name: an event, a declared trigger, or a host signal. The compiler resolves
-// the three in that order, and the editor offers them the same way rather than guessing which was meant.
-export function knownTriggerNames(symbols: DocumentSymbols): string[] {
-    return [
-        ...knownEventNames(symbols),
-        ...symbols.triggers.map((trigger) => trigger.name),
-        ...builtInTriggerNames,
-    ];
-}
-
-// Everything a property type reference can resolve to — the primitives, the declared
-// concepts and types, and the short names of the imports.
-export function knownTypeNames(symbols: DocumentSymbols, primitives: readonly string[]): string[] {
-    return [
-        ...primitives,
-        ...symbols.concepts.map((concept) => concept.name),
-        ...symbols.types.map((type) => type.name),
-        ...symbols.imports.map((imported) => imported.shortName),
-    ];
-}

package/themes/screenplay-dark.ts

@@ -1,33 +0,0 @@
-// 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.link.play', foreground: 'CE9178', fontStyle: 'underline' },
-        { 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

@@ -1,33 +0,0 @@
-// 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.link.play', foreground: 'A31515', fontStyle: 'underline' },
-        { 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',
-    },
-};