@cratis/screenplay-language 4.52.0 → 4.53.0

package/inline-event-validation.ts

@@ -1,115 +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 { DiagnosticCode, diagnosticCodes } from './diagnostic-codes';
-import { fenceMap, indentOf } from './document-context';
-import { productionDestinations } from './production-destinations';
-import { eventAnalysisSource } from './event-analysis-source';
-import { directBody, DocumentSymbols } from './symbols';
-import type { ValidationIssue, ValidationSeverity } from './validation';
-
-const reserved = new Set(['namespace', 'sequence', 'correlation', 'causation', 'causedBy', 'occurred']);
-const quotedId = /^id\s+"((?:[^"\\]|\\.)*)"$/;
-
-export function validateInlineEvents(lines: string[], symbols: DocumentSymbols, application: DocumentSymbols): ValidationIssue[] {
-    lines = eventAnalysisSource(lines);
-    const issues: ValidationIssue[] = [];
-    const fences = fenceMap(lines);
-    const documentationBlocks = nonemptyMarkdownBlocks(lines, fences);
-    const commandProductions = new Set(symbols.commands.flatMap(command => command.productionHeaders ?? []));
-    const eventCounts = new Map<string, number>();
-    const importedNames = new Set<string>();
-    for (const document of [symbols, application]) {
-        for (const event of document.events) eventCounts.set(event.name, (eventCounts.get(event.name) ?? 0) + 1);
-        for (const imported of document.imports) importedNames.add(imported.shortName);
-    }
-    const report = (line: number, code: DiagnosticCode, message: string, severity: ValidationSeverity = 'error') => {
-        issues.push({ line, startColumn: indentOf(lines[line]) + 1, endColumn: lines[line].length + 1, code, message, severity });
-    };
-    for (const event of symbols.events) {
-        const body = directBody(lines, fences, event.line, indentOf(lines[event.line]));
-        if (event.inline) {
-            const properties = new Set<string>();
-            for (const property of event.properties) {
-                if (properties.has(property.name)) report(property.line, diagnosticCodes.duplicateDeclaration, `Event '${event.name}' already declares property '${property.name}'.`);
-                properties.add(property.name);
-            }
-            if (!commandProductions.has(event.line)) report(event.line, diagnosticCodes.inlineEventOutsideCommand, 'Inline events can only be declared inside commands.');
-            if (event.generation !== undefined) report(event.line, diagnosticCodes.inlineEventGeneration, 'Inline events are generation 1; extract the event before declaring generations.');
-            if ((eventCounts.get(event.name) ?? 0) > 1 || importedNames.has(event.name)) {
-                report(event.line, diagnosticCodes.inlineEventCollision, `Inline event '${event.name}' collides with another declaration or import.`);
-            }
-        }
-        let hasId = false;
-        let hasDocumentation = false;
-        for (const index of body) {
-            const text = lines[index].trim();
-            const keyword = text.split(/\s+/)[0];
-            if (event.inline && keyword === 'generation') report(index, diagnosticCodes.inlineEventGeneration, 'Inline events are generation 1; extract the event before declaring generations.');
-            if (event.inline && keyword === 'origin') report(index, diagnosticCodes.reservedProductionMetadata, 'An inline event is local to its command and cannot declare origin.');
-            // Property-shaped metadata names stay properties, whether standalone or typed mappings.
-            if (/^(?:id|description|documentation)\s+[\w.]+(?:\[\])?\??(?:\s*=.*)?$/.test(text)) continue;
-            if (keyword === 'id') {
-                const match = text.match(quotedId);
-                if (hasId || match === null || match[1].trim().length === 0) report(index, diagnosticCodes.invalidEventId, 'Expected one nonempty id "<old-name>".');
-                else if (match[1] === event.name) report(index, diagnosticCodes.redundantEventId, 'This id repeats the event name; remove it.', 'information');
-                hasId = true;
-            }
-            if (keyword === 'documentation') {
-                let next = index + 1;
-                while (next < lines.length && lines[next].trim().length === 0) next++;
-                if (hasDocumentation || text !== 'documentation' || lines[next]?.trim() !== '```markdown' || indentOf(lines[next]) <= indentOf(lines[index]) ||
-                    !documentationBlocks.has(next)) {
-                    report(index, diagnosticCodes.invalidEventDocumentation, 'Expected one nonempty fenced markdown documentation block.');
-                }
-                hasDocumentation = true;
-            }
-        }
-    }
-    // Also cover reaction productions without a backward ancestry walk per metadata line.
-    const productionIndents: number[] = [];
-    for (let index = 0; index < lines.length; index++) {
-        if (fences[index] || lines[index].trim().length === 0) continue;
-        const indent = indentOf(lines[index]);
-        while (productionIndents.length > 0 && productionIndents[productionIndents.length - 1] >= indent) productionIndents.pop();
-        const keyword = lines[index].trim().split(/\s+/)[0];
-        if (reserved.has(keyword) && productionIndents.length > 0) {
-            report(index, diagnosticCodes.reservedProductionMetadata, `'${keyword}' is system-assigned production metadata.`);
-        }
-        if (keyword === 'produces') productionIndents.push(indent);
-    }
-    for (const command of symbols.commands) {
-        const { identifier, mixed } = productionDestinations(command);
-        for (const production of command.produces ?? []) {
-            if (mixed && production.target === undefined) report(production.line, diagnosticCodes.explicitProducesTargetsRequired, `Production '${production.name}' must state for explicitly when destinations differ.`);
-            const destination = production.target ?? (production.inline ? identifier : undefined);
-            if (identifier === undefined || destination !== identifier) continue;
-            for (const mapping of production.mappings.filter(mapping => mapping.source === identifier)) {
-                report(mapping.line, diagnosticCodes.eventSourceIdInPayload, `The payload copies '${identifier}', which already identifies the event source.`, production.inline ? 'warning' : 'information');
-            }
-        }
-    }
-    return issues;
-}
-
-// Record complete, nonempty Markdown fences once. Validation must not scan a suffix
-// for every documentation directive, especially while its opener is still being typed.
-function nonemptyMarkdownBlocks(lines: string[], fences: boolean[]): Set<number> {
-    const blocks = new Set<number>();
-    let opening: number | undefined;
-    let content = false;
-    for (let index = 0; index < lines.length; index++) {
-        if (!fences[index]) continue;
-        const text = lines[index].trim();
-        if (opening === undefined) {
-            opening = index;
-            content = false;
-        } else if (text === '```') {
-            if (content && lines[opening].trim() === '```markdown') blocks.add(opening);
-            opening = undefined;
-        } else if (text.length > 0) {
-            content = true;
-        }
-    }
-    return blocks;
-}

package/keyword-docs.ts

@@ -1,152 +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 { eventContextPaths } from './event-context';
-
-export const keywordDocs: Record<string, string> = {
-    domain: 'The domain the file belongs to — optional, at most one per file, before everything else.',
-    import: 'Imports a type from another module by its qualified name — `import Module.Type` — making it available by its short name; or, quoted, other `.play` files by path or glob — `import "Orders/**/*.play"`, relative to this file\'s folder. Written inside a module or feature, a file import places the imported files there: their top level is that module\'s or feature\'s body.',
-    concept: 'A formalized value type wrapping a primitive. Attributes such as `@pii` travel with every usage, optionally with a `<attribute> reason "..."` line saying why.',
-    type: 'A composite value type — a named shape built from several properties, referenced by events, commands and other types the same way a concept is.',
-    reason: 'Records why a concept attribute applies — the purpose, the lawful basis, whose subject the value lives under. Written as `pii reason "..."` in the concept body.',
-    identifier: 'Marks the command property a runtime resolves the event source id from. At most one per command; without it a new Uuid is generated.',
-    policy: 'A named authorization rule referenced by commands and queries. Multiple policies AND together.',
-    persona: 'A named role interacting with the application, with an optional description and its associated policies.',
-    authentication: 'Declares the identity providers of the application — at most one block per file.',
-    provider: 'A named identity provider within `authentication`, with free-form `name value` settings.',
-    description: 'A human-readable description of a module, feature, slice, persona, or command — the first body line, as a quoted single line or a fenced ```text block for multiple lines.',
-    module: 'The top-level namespace — maps to a bounded context.',
-    layout: 'A reusable screen template with named slots.',
-    template: 'Declares the named slots of a layout.',
-    feature: 'A vertical slice grouping. Features nest arbitrarily deep.',
-    slice: 'The atomic unit of behavior, aligned with Event Modeling. Has a type and a name.',
-    event: 'An immutable, past-tense fact. Declare it in a slice or inline with `produces event <Name>` in a command. Inline properties are typed mappings; inline tags belong to the event type.',
-    documentation: 'Authoring-only event documentation in a fenced ```markdown block. It does not change executable model bytes.',
-    id: 'Preserves the previous persisted event name after a rename. Leave absent on new events; repeating the current name is redundant.',
-    command: 'An imperative intent. Declares authorization, validation, and what events it produces — declaratively, or via a full handler.',
-    query: 'A read-side entry point mapping to a return type, with an optional description, parameters and performer.',
-    observable: 'Qualifies a query return type as a live read — `query <Name> => observable <ReadModel>` keeps pushing as the read model changes, instead of answering once.',
-    performer: 'The code that performs a query — a `file <Path>` reference or an inline `csharp`/`sql` block. The query\'s counterpart to a command handler.',
-    from: 'Fills a query parameter from the query context instead of the caller, as in `filter tenantId TenantId from $context.tenant`.',
-    projection: 'Declares how events project into a read model, using the embedded Projection Declaration Language (PDL).',
-    capture: 'Converts external data into events, using the embedded Change Data Capture Language (CDL).',
-    reaction: 'Behavior that runs when something happens. Lives inside Automation slices. A trigger with no body states intent on its own — `file`/code is optional realization metadata.',
-    trigger: 'Declares a kind of occurrence a reaction can respond to, and the values it hands the reaction. What makes one occur belongs to whoever provides it, never to the compiler.',
-    where: 'Narrows which occurrences actually run the reaction.',
-    contains: 'Text comparison — true when the left string holds the right one anywhere.',
-    every: 'Runs a reaction on an interval — `every 15 minutes`, `every 1 day`.',
-    invokes: 'A command a reaction hands on. A command is asked for, not produced — it may still be rejected.',
-    screen: 'A UI declaration. Supports intent, structure, and layout-with-code levels, or a full file reference.',
-    constraint: 'A server-side rule enforced in the Chronicle kernel before events are committed.',
-    authorize: 'References the policies that must all pass for the construct to execute.',
-    validate: 'Declarative validation rules, or `validate` followed by ```csharp for imperative rules — on commands and concepts.',
-    produces: 'References a declared event with `produces <Name>`, or declares one inline with `produces event <Name>`. An inline omitted `for` uses the command identifier only when all destinations are the same source; legacy plain omission allocates an identity.',
-    reads: 'Declares a view consulted by a command or reaction trigger: `reads <View> [as <alias>] [by <value>]`. A reaction `by` names a value taken by its trigger; clock triggers cannot use `by`. Repeated views require unique aliases. Runtime binding is not yet supported for command or reaction reads.',
-    as: 'Names an instance of a view in a command or reaction trigger reads declaration, for example `reads Account as source by sourceId`.',
-    handler: 'A fully imperative command implementation — a `file <Path>` reference or an inline `csharp` block, instead of `produces`.',
-    when: 'Guards a produced event or a capture append with a condition.',
-    rule: 'Names a predicate. Bare, it states that a constraint exists without expressing what it computes — nothing resolves the name. Optionally followed by an indented `file <Path>` reference or inline `csharp` block giving it a body.',
-    require: 'A policy condition: `authenticated`, `role "..."`, or `claim "..." matches ...`.',
-    authenticated: 'Requires an authenticated caller.',
-    role: 'Requires the caller to have the given role.',
-    claim: 'Requires a claim on the caller to match a subject or value.',
-    subject: 'The subject (identity) of the caller.',
-    data: 'Binds a read model to a screen through a query.',
-    action: 'Makes a command available as an action on a screen.',
-    navigate: 'Navigates to a screen, optionally passing a parameter with `by`.',
-    section: 'A named structural section of a screen.',
-    table: 'A table widget over a read model or child collection.',
-    summary: 'A summary widget showing labeled fields.',
-    column: 'A table column bound to a property.',
-    field: 'A summary field bound to a property.',
-    title: 'The display title of a screen or section.',
-    label: 'The display label of an action, column, or field.',
-    unique: 'A uniqueness constraint — `unique <property> on <EventType>` or `unique event <EventType>`.',
-    concurrency: 'The concurrency scope enforced when the command appends events — dimensions: `eventSource`, `sourceType`, `streamType`, `streamId`, `events`.',
-    eventSource: 'Concurrency dimension — scope the check to the event source id of the command.',
-    sourceType: 'Concurrency dimension — scope the check to an event source type.',
-    streamType: 'Concurrency dimension — scope the check to an event stream type.',
-    streamId: 'Concurrency dimension — scope the check to an event stream id.',
-    tag: 'Attaches a tag to appended events — a static identifier or string, or a `$context.` expression resolved at append time.',
-    seed: 'Declares events to seed into the event store per event source id — multiple blocks accumulate.',
-    for: 'Names the event source of a production or seed group. Inside `produces event`, omission uses the command identifier unless another production targets a different source.',
-    readmodel: 'Read model state in a specification — `given readmodel` establishes it, `then readmodel` asserts it, `then no readmodel <View> for <key>` asserts keyed absence.',
-    no: 'A keyed absence assertion: `then no readmodel <View> for <key>`.',
-    arguments: 'The values supplied to a query asserted by `then query`.',
-    result: 'One expected result - `then result [exactly]` after `when query`, or a `result` block inside `then query`. Repeat it to assert several results in authored order.',
-    clock: 'The instant a specification happens at - `given clock "2026-10-05T08:00:00Z"` fixes when everything occurs; `when clock "<instant>"` is the clock reaching it, as the action.',
-    exactly: 'Requires every property to match, rather than only the ones asserted - on `then readmodel`, `then query` and `then result`.',
-    file: 'Delegates the implementation to an external file; the Screenplay contract stays visible.',
-    by: 'Introduces the identifying parameter.',
-    via: 'Connects screen data to the query that supplies it.',
-    filter: 'An optional query filter parameter.',
-    on: 'The event a constraint applies to, the day a schedule narrows to, or a widget interaction such as `on row-click`.',
-    message: 'The validation message reported when the rule fails.',
-    matches: 'Matches a value against a regular expression or a named pattern such as `email`.',
-    all: 'Applies a comparison to every element of a collection.',
-    max: 'Maximum length or value.',
-    min: 'Minimum length or value.',
-    length: 'Constrains the exact length of a value.',
-    today: 'The current date.',
-    empty: 'Used with `not empty` — the value must be present.',
-    not: 'Negates a validation condition, as in `not empty`.',
-    and: 'Both conditions must hold.',
-    or: 'Either condition may hold.',
-    csharp: 'An inline C# block whose opening fence is ```csharp.',
-    sql: 'An inline SQL block between triple backticks — a query performer written against a relational store.',
-    typescript: 'An inline TypeScript block between triple backticks.',
-    react: 'An inline React/TSX block; receives the surrounding data contract as `Props`.',
-    html: 'An inline static HTML block.',
-    StateChange: 'Slice type — a command → events flow; something that changes the system.',
-    StateView: 'Slice type — a query + projection + screen; something that reads the system.',
-    Automation: 'Slice type — a reaction or reducer; something that runs when something happens.',
-    Translate: 'Slice type — a capture; converts external data into events.',
-    Uuid: 'Primitive type — a universally unique identifier.',
-    String: 'Primitive type — a string of characters.',
-    Int: 'Primitive type — an integer number.',
-    Decimal: 'Primitive type — a decimal number.',
-    Bool: 'Primitive type — true or false.',
-    Date: 'Primitive type — a date without time.',
-    DateTime: 'Primitive type — a date and time.',
-    Enum: 'An enumeration concept with a fixed set of values.',
-};
-
-// What the words of a specification's steps mean there - where 'trigger', 'capture' and 'query' name what the
-// scenario exercises rather than declare one.
-export const specificationKeywordDocs: Record<string, string> = {
-    clock: keywordDocs.clock,
-    trigger: '`when trigger <Trigger>` - an application trigger fires, as the action, with the values on the lines beneath it.',
-    capture: '`given capture <Capture>` - a record the capture\'s source held before; `when capture <Capture>` - the record it sees now, as the action. The fields go on the lines beneath.',
-    query: '`when query <Query>` - the query is performed, as the action, with its arguments on the lines beneath; assert what it returns with `then result` or `then no result`. `then query` instead asserts a query after another action.',
-    result: '`then result [exactly]` - one result the query performed by `when query` returns, in order; `then no result` - it returns nothing.',
-};
-
-export const attributeDocs: Record<string, string> = {
-    pii: '`@pii` — the value is personally identifiable information; Chronicle manages and erases it automatically wherever the concept is used. Add `pii reason "..."` in the concept body to record why.',
-    sensitive: '`@sensitive` — the value is sensitive; Chronicle applies its sensitivity rules automatically wherever the concept is used. Add `sensitive reason "..."` in the concept body to record why.',
-};
-
-export const contextVariableDocs: Record<string, string> = {
-    '$context.occurred': 'When the command or query was received.',
-    '$context.tenant': 'The tenant the command or query is executing for.',
-    '$context.command': 'The command being handled, shaped by its `command` declaration.',
-    '$context.arguments': 'The arguments of the query being performed.',
-    '$context.causedBy': 'The identity that caused the command or query — `subject`, `name`, `userName`.',
-    '$context.causedBy.subject': 'The subject of the identity that caused the command or query.',
-    '$context.causedBy.name': 'The display name of the identity that caused the command or query.',
-    '$context.causedBy.userName': 'The user name of the identity that caused the command or query.',
-    '$context.causation': 'What caused the command or query — `type`, `occurred`, `properties`.',
-    '$context.causation.type': 'What caused the command or query — a command, a reactor, a schedule.',
-    '$context.identity': 'The caller a decision is made about — `id`, `name`, `userName`, `isAuthenticated`, `roles`, `claims`.',
-    '$context.identity.id': 'The identifier of the caller from the auth token.',
-    '$context.identity.name': 'The display name of the caller.',
-    '$context.identity.userName': 'The user name of the caller.',
-    '$context.identity.isAuthenticated': 'Whether the caller is authenticated.',
-    '$context.identity.roles': 'The roles the caller holds.',
-    '$context.identity.claims': 'The claims the caller carries — `$context.identity.claims.<name>` reads one.',
-    '$env': 'An environment variable, e.g. `$env.SERVICE_NAME`.',
-    '$secrets': 'An encrypted secret resolved at runtime, e.g. `$secrets.azureAdClientId` — stays symbolic in the compiled tree.',
-    '$strings': 'A localized string resolved from the `.strings` file of the active locale, e.g. `$strings.invoices.title`.',
-    // Every $eventContext path the event-context catalog lists, for projections.
-    ...Object.fromEntries(eventContextPaths.map((path) => [`$eventContext.${path.path}`, path.description])),
-};

package/language.ts

@@ -1,212 +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');
-
-export const languageId = 'screenplay';
-
-export const languageExtensionPoint: languages.ILanguageExtensionPoint = {
-    id: languageId,
-    extensions: ['.play'],
-    aliases: ['Screenplay', 'screenplay', 'play'],
-    mimetypes: ['text/x-screenplay'],
-};
-
-// Every word the parser dispatches on at the top level, inside a module, or inside a slice.
-// `for_LanguageService.when_comparing_keywords_against_the_parsers` derives that set from
-// ScreenplayParser and SliceParser and fails when this list has drifted from it, so a construct
-// added to the compiler cannot silently lose its highlighting and completion.
-export const constructKeywords = [
-    'domain',
-    'import',
-    'concept',
-    'type',
-    'policy',
-    'persona',
-    'authentication',
-    'module',
-    'layout',
-    'theme',
-    'ui',
-    'feature',
-    'slice',
-    'event',
-    'command',
-    'query',
-    'projection',
-    'capture',
-    'reaction',
-    'reducer',
-    'trigger',
-    'screen',
-    'dialog',
-    'form',
-    'contribute',
-    'constraint',
-    'specification',
-    'seed',
-    'behavior',
-];
-
-export const clauseKeywords = [
-    'description',
-    'template',
-    'profile',
-    'require',
-    'authenticated',
-    'role',
-    'claim',
-    'subject',
-    'authorize',
-    'validate',
-    'produces',
-    'reads', // A clause in command bodies and reaction trigger bodies; @reads remains a value.
-    'as',
-    'handler',
-    'performer',
-    'observable',
-    'identifier',
-    'reason',
-    'from',
-    'when',
-    'given',
-    'then',
-    'arguments',
-    'result',
-    'clock', // A specification step - 'given clock' and 'when clock' state an instant.
-    'exactly',
-    'error',
-    'message',
-    'not',
-    'empty',
-    'rule',
-    'matches',
-    'all',
-    'max',
-    'min',
-    'length',
-    'today',
-    'true',
-    'false',
-    'and',
-    'or',
-    'by',
-    'filter',
-    'data',
-    'via',
-    'action',
-    'navigate',
-    'to',
-    'label',
-    'section',
-    'table',
-    'summary',
-    'title',
-    'column',
-    'field',
-    'on',
-    'unique',
-    'file',
-    'concurrency',
-    'eventSource',
-    'sourceType',
-    'streamType',
-    'streamId',
-    'tag',
-    'for',
-    'readmodel',
-    'no',
-    'when',
-    'every',
-    'at',
-    'where',
-    'invokes',
-    'contains',
-    'starts',
-    'with',
-    'provider',
-    // Interaction: the words a behavior body uses. The built-in interaction kinds ('click', 'submit', and
-    // friends) are only reserved inside an `on` clause, so they are clause words rather than constructs -
-    // an identifier of the same name elsewhere in a document remains an identifier.
-    'uses',
-    'parameter',
-    'order',
-    'execute',
-    'open',
-    'close',
-    'refresh',
-    'set',
-    'notify',
-    'confirm',
-    'raise',
-    'interval',
-    'success',
-    'failure',
-    'click',
-    'double',
-    'select',
-    'submit',
-    'change',
-    'load',
-    'unload',
-    'enter',
-    'leave',
-    'info',
-    'warning',
-];
-
-export const codeBlockTags = ['csharp', 'typescript', 'react', 'html', 'sql'];
-
-// The roots a `$context.` path can start with — the members of CommandContext and QueryContext.
-export const contextRoots = [
-    'command',
-    'arguments',
-    'tenant',
-    'causedBy',
-    'causation',
-    'occurred',
-    'identity',
-];
-
-export const causedByProperties = ['subject', 'name', 'userName'];
-
-// The properties a `$context.identity.` path can name — the members of Identity. Everything after
-// `claims.` is the name of a claim rather than a member, so it is never checked.
-export const identityProperties = ['id', 'name', 'userName', 'isAuthenticated', 'roles', 'claims'];
-
-export const sliceTypes = ['StateChange', 'StateView', 'Automation', 'Translate'];
-
-export const primitiveTypes = ['Uuid', 'String', 'Int', 'Decimal', 'Bool', 'Date', 'DateTime'];
-
-export const conceptAttributes = ['@pii', '@sensitive'];
-
-export const languageConfiguration: languages.LanguageConfiguration = {
-    comments: {
-        lineComment: '//',
-    },
-    brackets: [
-        ['(', ')'],
-        ['[', ']'],
-    ],
-    autoClosingPairs: [
-        { open: '(', close: ')' },
-        { open: '[', close: ']' },
-        { open: '"', close: '"' },
-    ],
-    surroundingPairs: [
-        { open: '(', close: ')' },
-        { open: '[', close: ']' },
-        { open: '"', close: '"' },
-    ],
-    folding: {
-        offSide: true,
-    },
-    indentationRules: {
-        increaseIndentPattern:
-            /^\s*(module|feature|slice|policy|persona|authentication|provider|event|command|query|type|screen|projection|capture|reaction|trigger|constraint|specification|layout|template|validate|produces|handler|performer|rule|section|concurrency|seed|for|when|then|arguments|result|every|at)\b.*$/,
-        // Dedents are always explicit in an offside language — never auto-dedent.
-        decreaseIndentPattern: /(?!)/,
-    },
-};

package/production-destinations.ts

@@ -1,32 +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 { DestinationHint } from './DestinationHint';
-import { eventAnalysisSource } from './event-analysis-source';
-import { CommandSymbol, scanDocument } from './symbols';
-
-export function productionDestinations(command: CommandSymbol): { identifier?: string; mixed: boolean } {
-    const identifiers = command.properties.filter(property => property.isIdentifier && !property.type.includes('?') && !property.type.includes('[]'));
-    const identifier = identifiers.length === 1 ? identifiers[0].name : undefined;
-    const productions = command.produces ?? [];
-    const mixed = productions.some(production => production.target !== undefined && production.target !== identifier) ||
-        (productions.some(production => production.inline && production.target === undefined) &&
-         productions.some(production => !production.inline && production.target === undefined));
-    return { identifier, mixed };
-}
-
-// Shared by both editor adapters. Never suggest that a legacy allocated source is the command identifier.
-export function destinationHints(lines: string[]): DestinationHint[] {
-    const source = eventAnalysisSource(lines);
-    return scanDocument(source).commands.flatMap(command => {
-        const { identifier, mixed } = productionDestinations(command);
-        if (mixed || command.productionHeaders?.length !== command.produces?.length) return [];
-        const hasPromotedDestination = command.produces?.some(sibling => sibling.target !== undefined || sibling.inline);
-        return (command.produces ?? []).flatMap(production => {
-            if (production.target !== undefined || (production.inline && (identifier === undefined || /\bgeneration\b/.test(source[production.line])))) return [];
-            // A sibling destination can promote the command default in the legacy binder.
-            if (!production.inline && hasPromotedDestination) return [];
-            return [{ line: production.line, column: source[production.line].length + 1, label: production.inline ? `for ${identifier}` : 'for <new event source>' }];
-        });
-    });
-}

package/sub-language-registry.ts

@@ -1,42 +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 MonarchTokenRules = languages.IMonarchLanguage['tokenizer'][string];
-
-export interface SubLanguageCompletion {
-    label: string;
-    insertText: string;
-    documentation: string;
-}
-
-export interface SubLanguageDefinition {
-    tokens: MonarchTokenRules;
-    completions?: SubLanguageCompletion[];
-    hovers?: Record<string, string>;
-}
-
-export interface SubLanguage extends SubLanguageDefinition {
-    keyword: string;
-}
-
-const subLanguages = new Map<string, SubLanguage>();
-const listeners = new Set<() => void>();
-
-export function registerSubLanguage(keyword: string, definition: SubLanguageDefinition): void {
-    subLanguages.set(keyword, { keyword, ...definition });
-    listeners.forEach((listener) => listener());
-}
-
-export function getSubLanguages(): SubLanguage[] {
-    return [...subLanguages.values()];
-}
-
-export function getSubLanguage(keyword: string): SubLanguage | undefined {
-    return subLanguages.get(keyword);
-}
-
-export function onSubLanguagesChanged(listener: () => void): void {
-    listeners.add(listener);
-}