@cratis/screenplay-language 4.51.0 → 4.53.0

package/sub-languages/capture/language.ts

@@ -1,176 +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 type Monaco = typeof import('monaco-editor');
-
-// Capture Declaration Language (CDL) — Chronicle's DSL for declaring change-data-capture
-// rules, registered here as its own standalone top-level Monaco language. This is distinct
-// from the lightweight CDL sub-language embedded inside a `.play` document's `capture`
-// blocks (../cdl.ts) — this module owns its own language id, tokenizer, and providers.
-export const languageId = 'cdl';
-
-// `route`/`poll` are API source properties; `path` is the webhook inbound path; `topic`
-// is the message source subject. There is no `auth`/`bearer`/`url` — an API source
-// references a named External Service (`api <ServiceName>`) for base URL and auth, and
-// a webhook source's authentication is configured on the source builder, not in CDL text.
-const KEYWORDS = [
-    'capture',
-    'source',
-    'key',
-    'map',
-    'append',
-    'when',
-    'nested',
-    'children',
-    'identified',
-    'by',
-    'api',
-    'webhook',
-    'message',
-    'route',
-    'poll',
-    'path',
-    'topic',
-    'from',
-    'to',
-    'or',
-    'and',
-    'added',
-    'removed',
-    'translate',
-    'split',
-] as const;
-
-const BUILTINS = [
-    '$context',
-    '$previous',
-    '$env',
-] as const;
-
-const OPERATORS = ['=', '=>', '.'];
-
-export const languageConfiguration: 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: /^.*(\bcapture\b\s+\S+|\bsource\b(?:\s+\w+)?|\bmap\b|\bappend\b\s+\S+|\bnested\b\s+\S+|\bchildren\b\s+\S+.*|\btranslate\b|\bsplit\b.*)\s*$/,
-        decreaseIndentPattern: /^.*\}.*$/,
-    },
-    folding: {
-        offSide: true,
-        markers: {
-            start: /^\s*(capture|source|map|append|nested|children|translate|split)/,
-            end: /^\s*$/,
-        },
-    },
-    wordPattern: /[$]?[a-zA-Z_][\w$-]*/,
-};
-
-export const monarchLanguage: languages.IMonarchLanguage = {
-    defaultToken: '',
-    tokenPostfix: '.cdl',
-
-    keywords: KEYWORDS,
-    builtins: BUILTINS,
-    operators: 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: [
-            { include: '@whitespace' },
-            [/`/, { token: 'string.template', next: '@templateString' }],
-            [/\$\.(?:[a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)?/, 'variable'],
-            [/\$previous(?:\.[a-zA-Z_]\w*(?:\.[a-zA-Z_]\w*)*)?/, 'variable.predefined'],
-            [/\$context(?:\.(?:occurred|eventSourceId))?/, 'variable.predefined'],
-            [/\$env(?:\.[A-Z_][A-Z0-9_]*)?/, 'variable.predefined'],
-            [/@[a-zA-Z_$][\w$]*/, 'identifier.escape'],
-            [
-                /[A-Z][a-zA-Z_$][\w$]*/,
-                {
-                    cases: {
-                        '@keywords': 'invalid',
-                        '@default': 'identifier',
-                    },
-                },
-            ],
-            [
-                /[a-z_$][\w$]*/,
-                {
-                    cases: {
-                        '@keywords': 'keyword',
-                        '@builtins': 'variable.predefined',
-                        '@default': 'identifier',
-                    },
-                },
-            ],
-            [/[{}()[\]]/, '@brackets'],
-            [/=>/, 'operator.arrow'],
-            [
-                /@symbols/,
-                {
-                    cases: {
-                        '@operators': 'operator',
-                        '@default': '',
-                    },
-                },
-            ],
-            [/\d*\.\d+([eE][-+]?\d+)?/, 'number.float'],
-            [/0[xX][0-9a-fA-F]+/, 'number.hex'],
-            [/\d+/, 'number'],
-            [/[;,.]/, 'delimiter'],
-            [/"([^"\\]|\\.)*$/, 'string.invalid'],
-            [/"/, { token: 'string.quote', next: '@string' }],
-        ],
-
-        whitespace: [
-            [/[ \t\r\n]+/, ''],
-            [/#.*$/, 'comment'],
-        ],
-
-        templateString: [
-            [/\$\{/, { token: 'delimiter.bracket', next: '@templateExpression' }],
-            [/[^\\`$]+/, 'string.template'],
-            [/@escapes/, 'string.template.escape'],
-            [/\\./, 'string.template.escape.invalid'],
-            [/`/, { token: 'string.template', next: '@pop' }],
-        ],
-
-        templateExpression: [
-            [/\}/, { token: 'delimiter.bracket', next: '@pop' }],
-            { include: '@root' },
-        ],
-
-        string: [
-            [/[^\\"]+/, 'string'],
-            [/@escapes/, 'string.escape'],
-            [/\\./, 'string.escape.invalid'],
-            [/"/, { token: 'string.quote', next: '@pop' }],
-        ],
-    },
-};

package/sub-languages/cdl.ts

@@ -1,76 +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 { SubLanguageDefinition } from '../sub-language-registry';
-
-// Change Data Capture Language (CDL) — embedded inside `capture` blocks. This is the
-// lightweight definition mixed into the composite `.play` tokenizer; the full standalone
-// CDL language (its own tokenizer, context-aware completions, hover, and validation) lives
-// in `./capture` and is what `@cratis/screenplay-language/capture` exposes to consumers.
-export const cdl: SubLanguageDefinition = {
-    tokens: [
-        [
-            /\b(?:source|api|route|poll|path|topic|key|map|translate|split|append|tag|when|children|nested|identified|by|from|to|and|or|added|removed)\b/,
-            'keyword',
-        ],
-    ],
-    completions: [
-        {
-            label: 'source',
-            insertText: 'source ${1:api}',
-            documentation: 'Declares where the captured data comes from.',
-        },
-        {
-            label: 'key',
-            insertText: 'key ${1:property}',
-            documentation: 'Declares which source property identifies an instance.',
-        },
-        {
-            label: 'map',
-            insertText: 'map\n    ${1:property} = ${2:source}',
-            documentation: 'Maps and translates source values before events are appended.',
-        },
-        {
-            label: 'append',
-            insertText: 'append ${1:EventType}\n    when ${2:property}',
-            documentation: 'Appends an event when the source data changes.',
-        },
-        {
-            label: 'translate',
-            insertText: 'translate\n    "${1:source}" => ${2:target}',
-            documentation: 'Translates source values into Screenplay values.',
-        },
-        {
-            label: 'children',
-            insertText: 'children ${1:collection} identified by ${2:key}',
-            documentation: 'Captures changes in a child collection of the source data.',
-        },
-        {
-            label: 'when added',
-            insertText: 'when added',
-            documentation: 'Appends the event when a new item appears in the source.',
-        },
-        {
-            label: 'when removed',
-            insertText: 'when removed',
-            documentation: 'Appends the event when an item disappears from the source.',
-        },
-    ],
-    hovers: {
-        source: 'CDL — declares where the captured data comes from.',
-        api: 'CDL — as a source type, polls an HTTP API; as a source property (`api <ServiceName>`), references a named External Service for the base URL and authentication.',
-        route: 'CDL — optional path appended to an API source\'s External Service base URL.',
-        poll: 'CDL — the polling interval for an API source, e.g. 5m.',
-        path: 'CDL — the inbound path a webhook source listens on.',
-        topic: 'CDL — the topic a message source subscribes to.',
-        key: 'CDL — declares which source property identifies an instance.',
-        map: 'CDL — maps and translates source values before events are appended.',
-        translate: 'CDL — translates source values into Screenplay values.',
-        append: 'CDL — appends an event when the source data changes.',
-        when: 'CDL — the change condition: a property change, added, or removed.',
-        added: 'CDL — matches items that appear in the source.',
-        removed: 'CDL — matches items that disappear from the source.',
-        children: 'CDL — captures changes in a child collection of the source data.',
-        identified: 'CDL — introduces the identifying key of a child collection.',
-    },
-};

package/sub-languages/pdl.ts

@@ -1,75 +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 { SubLanguageDefinition } from '../sub-language-registry';
-
-// Projection Declaration Language (PDL) — embedded inside `projection` blocks.
-// See https://www.cratis.io/chronicle/projections/projection-declaration-language/grammar/
-export const pdl: SubLanguageDefinition = {
-    tokens: [
-        [
-            /\b(?:from|every|all|nested|join|children|identified|by|key|parent|with|remove|via|clear|on|sequence|automap|no|exclude|literal|set|increment|decrement|add|subtract|count)\b/,
-            'keyword',
-        ],
-    ],
-    completions: [
-        {
-            label: 'key',
-            insertText: 'key ${1:property}',
-            documentation: 'Declares which property identifies the read model instance.',
-        },
-        {
-            label: 'from',
-            insertText: 'from ${1:EventType}',
-            documentation: 'Maps properties from an event onto the read model.',
-        },
-        {
-            label: 'join',
-            insertText: 'join ${1:property} on ${2:key}',
-            documentation: 'Joins related state onto the read model by a key property.',
-        },
-        {
-            label: 'children',
-            insertText: 'children ${1:collection} identified by ${2:key}',
-            documentation: 'Projects events into a child collection on the read model.',
-        },
-        {
-            label: 'remove with',
-            insertText: 'remove with ${1:EventType}',
-            documentation: 'Removes the read model instance when the event occurs.',
-        },
-        {
-            label: 'parent',
-            insertText: 'parent ${1:property}',
-            documentation: 'Declares the property that identifies the parent of a child.',
-        },
-        {
-            label: 'clear',
-            insertText: 'clear ${1:property}',
-            documentation: 'Removes the value a property holds when the event occurs.',
-        },
-        {
-            label: 'increment',
-            insertText: 'increment ${1:property}',
-            documentation: 'Increments a numeric property when the event occurs.',
-        },
-        {
-            label: 'decrement',
-            insertText: 'decrement ${1:property}',
-            documentation: 'Decrements a numeric property when the event occurs.',
-        },
-    ],
-    hovers: {
-        from: 'PDL — maps properties from an event onto the read model.',
-        every: 'PDL — applies property mappings for every event type in the projection.',
-        join: 'PDL — joins related state onto the read model by a key property.',
-        children: 'PDL — projects events into a child collection on the read model.',
-        identified: 'PDL — introduces the identifying key of a child collection.',
-        key: 'PDL — declares which property identifies the read model instance.',
-        parent: 'PDL — declares the property that identifies the parent of a child.',
-        remove: 'PDL — removes the read model instance when an event occurs.',
-        clear: 'PDL — clear <property> removes the value a property holds; clear with <EventType> nulls a nested object.',
-        increment: 'PDL — increments a numeric property when the event occurs.',
-        decrement: 'PDL — decrements a numeric property when the event occurs.',
-    },
-};

package/sub-languages/projection/CodeActionProvider.ts

@@ -1,123 +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 * as Monaco from 'monaco-editor';
-import type { JsonSchema, ReadModelInfo, DraftReadModelInfo } from './index';
-
-export class CodeActionProvider {
-    private readModels: ReadModelInfo[] = [];
-    private draftReadModel: DraftReadModelInfo | null = null;
-    private onCreateReadModel?: (readModelName: string) => void;
-    private onEditReadModel?: (readModelName: string, currentSchema: JsonSchema) => void;
-
-    setReadModels(readModels: ReadModelInfo[]): void {
-        this.readModels = readModels;
-    }
-
-    setDraftReadModel(draft: DraftReadModelInfo | null): void {
-        this.draftReadModel = draft;
-    }
-
-    // Keep for backwards compatibility
-    setReadModelSchemas(schemas: JsonSchema[]): void {
-        this.readModels = schemas.map(schema => ({
-            identifier: schema.title || schema.name || '',
-            displayName: schema.title || schema.name || '',
-            schema
-        }));
-    }
-
-    setCreateReadModelCallback(callback: (readModelName: string) => void): void {
-        this.onCreateReadModel = callback;
-    }
-
-    setEditReadModelCallback(callback: (readModelName: string, currentSchema: JsonSchema) => void): void {
-        this.onEditReadModel = callback;
-    }
-
-    invokeCreateReadModel(readModelName: string): void {
-        this.onCreateReadModel?.(readModelName);
-    }
-
-    invokeEditReadModel(readModelName: string, currentSchema: JsonSchema): void {
-        this.onEditReadModel?.(readModelName, currentSchema);
-    }
-
-    provideCodeActions(
-        _model: Monaco.editor.ITextModel,
-        _range: Monaco.Range,
-        context: Monaco.languages.CodeActionContext
-    ): Monaco.languages.ProviderResult<Monaco.languages.CodeActionList> {
-        const actions: Monaco.languages.CodeAction[] = [];
-
-        // Check for diagnostics about undefined read models (errors)
-        const notFoundDiagnostics = context.markers.filter(
-            (marker: Monaco.editor.IMarkerData) => marker.message.includes("Read model") && marker.message.includes("not found")
-        );
-
-        // Check for diagnostics about draft read models (info markers)
-        const draftDiagnostics = context.markers.filter(
-            (marker: Monaco.editor.IMarkerData) => marker.message.includes("Read model") && marker.message.includes("is a draft")
-        );
-
-        // Handle "not found" errors - offer to create
-        for (const diagnostic of notFoundDiagnostics) {
-            const match = diagnostic.message.match(/Read model ['"]([\w.]+)['"]/);
-            if (match && match[1]) {
-                const readModelName = match[1];
-
-                // Check if this read model already exists as a persisted read model
-                const existsAsPersisted = this.readModels.some(
-                    rm => rm.identifier === readModelName || rm.displayName === readModelName
-                );
-
-                if (!existsAsPersisted && this.onCreateReadModel) {
-                    actions.push({
-                        title: `Create read model '${readModelName}'`,
-                        diagnostics: [diagnostic],
-                        kind: 'quickfix',
-                        edit: undefined,
-                        isPreferred: true,
-                        command: {
-                            id: 'pdl.createReadModel',
-                            title: `Create ${readModelName}`,
-                            arguments: [readModelName]
-                        }
-                    });
-                }
-            }
-        }
-
-        // Handle draft read model info markers - offer to edit
-        for (const diagnostic of draftDiagnostics) {
-            const match = diagnostic.message.match(/Read model ['"]([\w.]+)['"]/);
-            if (match && match[1]) {
-                const readModelName = match[1];
-
-                if (this.draftReadModel && this.isDraftReadModel(readModelName) && this.onEditReadModel) {
-                    actions.push({
-                        title: `Edit read model '${readModelName}'`,
-                        diagnostics: [diagnostic],
-                        kind: 'quickfix',
-                        edit: undefined,
-                        isPreferred: true,
-                        command: {
-                            id: 'pdl.editReadModel',
-                            title: `Edit ${readModelName}`,
-                            arguments: [readModelName, this.draftReadModel.schema]
-                        }
-                    });
-                }
-            }
-        }
-
-        return {
-            actions,
-            dispose: () => { /* No cleanup needed */ }
-        };
-    }
-
-    private isDraftReadModel(readModelToken: string): boolean {
-        return !!this.draftReadModel && (this.draftReadModel.identifier === readModelToken || this.draftReadModel.displayName === readModelToken);
-    }
-}