@cratis/screenplay-language 4.51.0 → 4.53.0

package/event-context-catalog.ts

@@ -1,135 +0,0 @@
-// Copyright (c) Cratis. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-// Generated from Cratis.Screenplay.Syntax.EventContextCatalog - do not edit by hand. The spec
-// Syntax/for_EventContextCatalog/when_holding_the_editor_catalog_to_it fails when this file drifts; rerun
-// it with SCREENPLAY_REGENERATE_EVENT_CONTEXT=1 to rewrite it.
-
-export type EventContextMemberKind = 'value' | 'composite' | 'collection' | 'function';
-
-export interface EventContextMember {
-    readonly name: string;
-    readonly type: string;
-    readonly kind: EventContextMemberKind;
-    readonly description: string;
-}
-
-export interface EventContextPath extends EventContextMember {
-    readonly path: string;
-}
-
-export const eventContextRootType = 'EventContext';
-
-// The members of each type a path passes through, keyed by type name.
-export const eventContextTypes: Readonly<Record<string, readonly EventContextMember[]>> = {
-    'EventContext': [
-        { name: 'eventType', type: 'EventType', kind: 'composite', description: 'The type of the event - its identifier, generation and whether it is a tombstone.' },
-        { name: 'eventSourceType', type: 'EventSourceType', kind: 'value', description: 'The type of the event source the event was appended to.' },
-        { name: 'eventSourceId', type: 'EventSourceId', kind: 'value', description: 'The identifier of the event source the event was appended to - the value $eventSourceId resolves.' },
-        { name: 'eventStreamType', type: 'EventStreamType', kind: 'value', description: 'The type of the event stream the event belongs to.' },
-        { name: 'eventStreamId', type: 'EventStreamId', kind: 'value', description: 'The identifier of the event stream the event belongs to.' },
-        { name: 'sequenceNumber', type: 'EventSequenceNumber', kind: 'value', description: 'The position of the event in its event sequence.' },
-        { name: 'occurred', type: 'DateTimeOffset', kind: 'value', description: 'When the event occurred - the time it was appended unless one was given.' },
-        { name: 'eventStore', type: 'EventStoreName', kind: 'value', description: 'The name of the event store the event belongs to.' },
-        { name: 'namespace', type: 'EventStoreNamespaceName', kind: 'value', description: 'The namespace within the event store the event belongs to.' },
-        { name: 'correlationId', type: 'CorrelationId', kind: 'value', description: 'The correlation identifier the event was appended with.' },
-        { name: 'causation', type: 'IEnumerable<Causation>', kind: 'collection', description: 'The chain of causes that led to the event - a collection, not addressable below.' },
-        { name: 'causedBy', type: 'Identity', kind: 'composite', description: 'The identity that caused the event.' },
-        { name: 'tags', type: 'IEnumerable<Tag>', kind: 'collection', description: 'The tags the event was appended with - a collection, not addressable below.' },
-        { name: 'hash', type: 'EventHash', kind: 'value', description: 'The hash of the event content.' },
-        { name: 'observationState', type: 'EventObservationState', kind: 'value', description: 'Whether the observer sees the event for the first time or again on replay - differs between live processing and replay.' },
-        { name: 'subject', type: 'Subject', kind: 'value', description: 'The compliance subject the event is about - the event source identifier unless one was given.' },
-        { name: 'subjectIsEventSourceId', type: 'bool', kind: 'value', description: 'Whether the subject is the event source identifier.' },
-    ],
-    'EventType': [
-        { name: 'id', type: 'EventTypeId', kind: 'value', description: 'The identifier of the event type.' },
-        { name: 'generation', type: 'EventTypeGeneration', kind: 'value', description: 'The generation of the event type.' },
-        { name: 'tombstone', type: 'bool', kind: 'value', description: 'Whether the event is a tombstone event.' },
-    ],
-    'EventSourceType': [
-        { name: 'value', type: 'string', kind: 'value', description: 'The underlying string value.' },
-    ],
-    'EventSourceId': [
-        { name: 'value', type: 'string', kind: 'value', description: 'The underlying string value.' },
-    ],
-    'EventStreamType': [
-        { name: 'value', type: 'string', kind: 'value', description: 'The underlying string value.' },
-    ],
-    'EventStreamId': [
-        { name: 'value', type: 'string', kind: 'value', description: 'The underlying string value.' },
-    ],
-    'EventSequenceNumber': [
-        { name: 'value', type: 'ulong', kind: 'value', description: 'The underlying ulong value.' },
-    ],
-    'DateTimeOffset': [
-        { name: 'Week', type: 'int', kind: 'function', description: 'The ISO 8601 week of the year the value falls in.' },
-    ],
-    'EventStoreName': [
-        { name: 'value', type: 'string', kind: 'value', description: 'The underlying string value.' },
-    ],
-    'EventStoreNamespaceName': [
-        { name: 'value', type: 'string', kind: 'value', description: 'The underlying string value.' },
-    ],
-    'CorrelationId': [
-        { name: 'value', type: 'Guid', kind: 'value', description: 'The underlying Guid value.' },
-    ],
-    'Identity': [
-        { name: 'subject', type: 'string', kind: 'value', description: 'The subject identifier of the identity.' },
-        { name: 'name', type: 'string', kind: 'value', description: 'The display name of the identity.' },
-        { name: 'userName', type: 'string', kind: 'value', description: 'The user name of the identity.' },
-        { name: 'onBehalfOf', type: 'Identity', kind: 'composite', description: 'The identity this identity acted on behalf of, if any - an identity with the same members.' },
-    ],
-    'EventHash': [
-        { name: 'value', type: 'string', kind: 'value', description: 'The underlying string value.' },
-    ],
-    'Subject': [
-        { name: 'value', type: 'string', kind: 'value', description: 'The underlying string value.' },
-    ],
-    'EventTypeId': [
-        { name: 'value', type: 'string', kind: 'value', description: 'The underlying string value.' },
-    ],
-    'EventTypeGeneration': [
-        { name: 'value', type: 'uint', kind: 'value', description: 'The underlying uint value.' },
-    ],
-};
-
-// Every path the catalog lists, depth first in declaration order.
-export const eventContextPaths: readonly EventContextPath[] = [
-    { path: 'eventType', name: 'eventType', type: 'EventType', kind: 'composite', description: 'The type of the event - its identifier, generation and whether it is a tombstone.' },
-    { path: 'eventType.id', name: 'id', type: 'EventTypeId', kind: 'value', description: 'The identifier of the event type.' },
-    { path: 'eventType.id.value', name: 'value', type: 'string', kind: 'value', description: 'The underlying string value.' },
-    { path: 'eventType.generation', name: 'generation', type: 'EventTypeGeneration', kind: 'value', description: 'The generation of the event type.' },
-    { path: 'eventType.generation.value', name: 'value', type: 'uint', kind: 'value', description: 'The underlying uint value.' },
-    { path: 'eventType.tombstone', name: 'tombstone', type: 'bool', kind: 'value', description: 'Whether the event is a tombstone event.' },
-    { path: 'eventSourceType', name: 'eventSourceType', type: 'EventSourceType', kind: 'value', description: 'The type of the event source the event was appended to.' },
-    { path: 'eventSourceType.value', name: 'value', type: 'string', kind: 'value', description: 'The underlying string value.' },
-    { path: 'eventSourceId', name: 'eventSourceId', type: 'EventSourceId', kind: 'value', description: 'The identifier of the event source the event was appended to - the value $eventSourceId resolves.' },
-    { path: 'eventSourceId.value', name: 'value', type: 'string', kind: 'value', description: 'The underlying string value.' },
-    { path: 'eventStreamType', name: 'eventStreamType', type: 'EventStreamType', kind: 'value', description: 'The type of the event stream the event belongs to.' },
-    { path: 'eventStreamType.value', name: 'value', type: 'string', kind: 'value', description: 'The underlying string value.' },
-    { path: 'eventStreamId', name: 'eventStreamId', type: 'EventStreamId', kind: 'value', description: 'The identifier of the event stream the event belongs to.' },
-    { path: 'eventStreamId.value', name: 'value', type: 'string', kind: 'value', description: 'The underlying string value.' },
-    { path: 'sequenceNumber', name: 'sequenceNumber', type: 'EventSequenceNumber', kind: 'value', description: 'The position of the event in its event sequence.' },
-    { path: 'sequenceNumber.value', name: 'value', type: 'ulong', kind: 'value', description: 'The underlying ulong value.' },
-    { path: 'occurred', name: 'occurred', type: 'DateTimeOffset', kind: 'value', description: 'When the event occurred - the time it was appended unless one was given.' },
-    { path: 'occurred.Week', name: 'Week', type: 'int', kind: 'function', description: 'The ISO 8601 week of the year the value falls in.' },
-    { path: 'eventStore', name: 'eventStore', type: 'EventStoreName', kind: 'value', description: 'The name of the event store the event belongs to.' },
-    { path: 'eventStore.value', name: 'value', type: 'string', kind: 'value', description: 'The underlying string value.' },
-    { path: 'namespace', name: 'namespace', type: 'EventStoreNamespaceName', kind: 'value', description: 'The namespace within the event store the event belongs to.' },
-    { path: 'namespace.value', name: 'value', type: 'string', kind: 'value', description: 'The underlying string value.' },
-    { path: 'correlationId', name: 'correlationId', type: 'CorrelationId', kind: 'value', description: 'The correlation identifier the event was appended with.' },
-    { path: 'correlationId.value', name: 'value', type: 'Guid', kind: 'value', description: 'The underlying Guid value.' },
-    { path: 'causation', name: 'causation', type: 'IEnumerable<Causation>', kind: 'collection', description: 'The chain of causes that led to the event - a collection, not addressable below.' },
-    { path: 'causedBy', name: 'causedBy', type: 'Identity', kind: 'composite', description: 'The identity that caused the event.' },
-    { path: 'causedBy.subject', name: 'subject', type: 'string', kind: 'value', description: 'The subject identifier of the identity.' },
-    { path: 'causedBy.name', name: 'name', type: 'string', kind: 'value', description: 'The display name of the identity.' },
-    { path: 'causedBy.userName', name: 'userName', type: 'string', kind: 'value', description: 'The user name of the identity.' },
-    { path: 'causedBy.onBehalfOf', name: 'onBehalfOf', type: 'Identity', kind: 'composite', description: 'The identity this identity acted on behalf of, if any - an identity with the same members.' },
-    { path: 'tags', name: 'tags', type: 'IEnumerable<Tag>', kind: 'collection', description: 'The tags the event was appended with - a collection, not addressable below.' },
-    { path: 'hash', name: 'hash', type: 'EventHash', kind: 'value', description: 'The hash of the event content.' },
-    { path: 'hash.value', name: 'value', type: 'string', kind: 'value', description: 'The underlying string value.' },
-    { path: 'observationState', name: 'observationState', type: 'EventObservationState', kind: 'value', description: 'Whether the observer sees the event for the first time or again on replay - differs between live processing and replay.' },
-    { path: 'subject', name: 'subject', type: 'Subject', kind: 'value', description: 'The compliance subject the event is about - the event source identifier unless one was given.' },
-    { path: 'subject.value', name: 'value', type: 'string', kind: 'value', description: 'The underlying string value.' },
-    { path: 'subjectIsEventSourceId', name: 'subjectIsEventSourceId', type: 'bool', kind: 'value', description: 'Whether the subject is the event source identifier.' },
-];

package/event-context.ts

@@ -1,119 +0,0 @@
-// Copyright (c) Cratis. All rights reserved.
-// Licensed under the MIT license. See LICENSE file in the project root for full license information.
-
-// Reads the generated event-context catalog. Every editor surface that describes $eventContext - projection
-// completion and hover, and the host editor's context-variable docs and completions - goes through here, so
-// none of them carries a list of its own.
-
-import { eventContextPaths, eventContextRootType, eventContextTypes } from './event-context-catalog';
-import type { EventContextMember, EventContextPath } from './event-context-catalog';
-
-export { eventContextPaths };
-export type { EventContextMember, EventContextPath };
-
-/**
- * Whether a written path segment names a member. Mirrors EventContextMember.IsNamedBy in the compiler: a property
- * resolves camelCase or with only its first character uppercased; a function resolves by its exact name, with or
- * without parentheses.
- */
-export function namesEventContextMember(member: EventContextMember, segment: string): boolean {
-    if (member.kind === 'function') {
-        return segment === member.name || segment === `${member.name}()`;
-    }
-
-    const declared = member.name[0].toUpperCase() + member.name.slice(1);
-    return segment === declared || (segment.length > 0 && segment[0].toUpperCase() + segment.slice(1) === declared);
-}
-
-/** The members of the event context itself - the first segment of every path. */
-export const eventContextMembers: readonly EventContextMember[] = eventContextTypes[eventContextRootType];
-
-/**
- * The members that may follow the given segments after `$eventContext.`, or undefined when the segments do not
- * resolve or stop at a collection or function, below which nothing is addressable.
- */
-export function eventContextMembersAfter(segments: readonly string[]): readonly EventContextMember[] | undefined {
-    let members = eventContextMembers;
-    for (const segment of segments) {
-        const member = members.find((candidate) => namesEventContextMember(candidate, segment));
-        if (!member || member.kind === 'collection' || member.kind === 'function') {
-            return undefined;
-        }
-
-        members = eventContextTypes[member.type] ?? [];
-    }
-
-    return members;
-}
-
-/** The member the given segments name, or undefined when they do not resolve. */
-export function eventContextMemberAt(segments: readonly string[]): EventContextMember | undefined {
-    if (segments.length === 0) {
-        return undefined;
-    }
-
-    const members = eventContextMembersAfter(segments.slice(0, -1));
-    return members?.find((member) => namesEventContextMember(member, segments[segments.length - 1]));
-}
-
-/** The outcome of resolving a path against the catalog. Mirrors EventContextPathStatus in the compiler. */
-export type EventContextPathStatus = 'known' | 'missing' | 'unknownMember' | 'unknownSubPath' | 'belowCollection';
-
-/** A path resolved against the catalog. Mirrors EventContextPathResolution in the compiler. */
-export interface EventContextPathResolution {
-    readonly status: EventContextPathStatus;
-    readonly member?: EventContextMember;
-    readonly segment?: string;
-    readonly expected: readonly EventContextMember[];
-}
-
-/**
- * Resolves a path, as written after `$eventContext.`, the way EventContextCatalog.Resolve in the compiler does, so the
- * editor reports what the compiler reports.
- */
-export function resolveEventContextPath(path: string): EventContextPathResolution {
-    let current: EventContextMember | undefined;
-    let expected = eventContextMembers;
-    for (const segment of path.split('.')) {
-        if (segment.length === 0) {
-            return { status: 'missing', member: current, expected };
-        }
-
-        if (current?.kind === 'collection') {
-            return { status: 'belowCollection', member: current, segment, expected: [] };
-        }
-
-        const next = expected.find((member) => namesEventContextMember(member, segment));
-        if (!next) {
-            return { status: current ? 'unknownSubPath' : 'unknownMember', member: current, segment, expected };
-        }
-
-        current = next;
-        expected = next.kind === 'function' ? [] : eventContextTypes[next.type] ?? [];
-    }
-
-    return { status: 'known', member: current, expected: [] };
-}
-
-/** Markdown describing $eventContext and its members, for hovers. */
-export function describeEventContext(): string {
-    return [
-        '**$eventContext**',
-        '',
-        'Metadata about the event being projected. Paths are checked against the event-context catalog; `causation` and `tags` are collections and cannot be addressed below.',
-        '',
-        '**Members:**',
-        ...eventContextMembers.map((member) => `- \`${member.name}\` (${member.type}) - ${member.description}`),
-    ].join('\n');
-}
-
-/** Markdown describing one member of the event context, for hovers. */
-export function describeEventContextMember(path: string, member: EventContextMember): string {
-    const below = member.kind === 'collection' || member.kind === 'function' ? [] : eventContextTypes[member.type] ?? [];
-    const lines = [`**$eventContext.${path}**: \`${member.type}\``, '', member.description];
-    if (below.length > 0) {
-        lines.push('', `**Members:** ${below.map((child) => `\`${child.name}\``).join(', ')}`);
-    }
-
-    return lines.join('\n');
-}

package/file-imports.ts

@@ -1,70 +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';
-
-// An `import "<path or glob>"` of other .play files, with the pattern exactly as written and the span it
-// occupies between the quotes. Columns are one-based like every other position this package reports.
-export interface FileImport {
-    pattern: string;
-    line: number;
-    startColumn: number;
-    endColumn: number;
-}
-
-// The compiler's own shape for a file import (FileImportParser): a quoted operand without quotes or escapes.
-const fileImportPattern = /^import(\s+)"([^"\\]+)"\s*(?:\/\/.*)?$/;
-const quotedImportPattern = /^import\s+"/;
-
-// Whether a line imports files rather than a qualified name - its operand is quoted.
-export function isFileImportLine(line: string): boolean {
-    return quotedImportPattern.test(line.trim());
-}
-
-// The file import on a single line, or undefined when the line is not a well-formed one.
-export function fileImportOn(line: string, lineIndex: number): FileImport | undefined {
-    const indent = indentOf(line);
-    const match = line.slice(indent).match(fileImportPattern);
-    if (!match) return undefined;
-    const startColumn = indent + 'import'.length + match[1].length + 2;
-    return { pattern: match[2], line: lineIndex, startColumn, endColumn: startColumn + match[2].length };
-}
-
-// Every well-formed file import in a document, in document order, skipping code fences.
-export function fileImports(lines: string[]): FileImport[] {
-    const fences = fenceMap(lines);
-    const found: FileImport[] = [];
-    for (let index = 0; index < lines.length; index++) {
-        if (fences[index]) continue;
-        const fileImport = fileImportOn(lines[index], index);
-        if (fileImport) found.push(fileImport);
-    }
-    return found;
-}
-
-const folderOf = (path: string): string[] => path.split('/').slice(0, -1);
-
-function relativeTo(from: readonly string[], path: string): string {
-    const segments = path.split('/');
-    let common = 0;
-    while (common < from.length && common < segments.length - 1 && from[common] === segments[common]) common++;
-    return [...from.slice(common).map(() => '..'), ...segments.slice(common)].join('/');
-}
-
-// What an import written in a document can name: every other .play file, relative to the document's folder;
-// a glob for the files directly in each folder holding one; and a glob for everything beneath each folder on
-// the way to them. Paths are portable ('/' separated) and relative to one root, the way the compiler resolves them.
-export function importablePaths(documentPath: string, files: readonly string[]): string[] {
-    const from = folderOf(documentPath);
-    const paths = new Set<string>();
-    for (const file of files.filter((candidate) => candidate !== documentPath && candidate.toLowerCase().endsWith('.play'))) {
-        const relative = relativeTo(from, file);
-        const folders = folderOf(relative);
-        paths.add(relative);
-        paths.add([...folders, '*.play'].join('/'));
-        for (let depth = 0; depth <= folders.length; depth++) {
-            paths.add([...folders.slice(0, depth), '**', '*.play'].join('/'));
-        }
-    }
-    return [...paths].sort();
-}

package/file-references.ts

@@ -1,87 +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, firstWord, indentOf } from './document-context';
-
-// The keyword the directive opens with — the single word the language points at a file with.
-export const fileReferenceKeyword = 'file';
-
-// A `file <path>` directive, with the path exactly as written and the span it occupies on its line.
-// The span is measured against the raw line, and its columns are one-based like every other position
-// this package reports, so an editor places a range on it the same way it does a validation issue.
-export interface FileReference {
-    path: string;
-    line: number;
-    startColumn: number;
-    endColumn: number;
-}
-
-// `file String` is a property named `file`; `file Invoices/Register.cs` is the directive. The two are
-// told apart by shape, the way the compiler tells them apart: a type reference is a bare identifier,
-// so anything carrying a separator or an extension is a path and nothing else. The property wins the
-// tie, because a document that used the name before the directive existed keeps meaning what it meant.
-const typeReferencePattern = /^[A-Za-z_]\w*(?:\[\])?\??$/;
-
-// A path naming a place on one machine rather than a place in the repository. The compiler warns about
-// these; nothing here rejects one, so a resolver can still probe it and come up empty on other machines.
-const absolutePathPattern = /^(?:[/\\]|[A-Za-z]:[/\\]|~[/\\])/;
-
-export function isAbsoluteFileReferencePath(path: string): boolean {
-    return absolutePathPattern.test(path);
-}
-
-// Drops a trailing `//` comment without cutting into a string or a template, mirroring how the
-// compiler strips one before it reads the line.
-function withoutComment(text: string): string {
-    let inString = false;
-    let inTemplate = false;
-
-    for (let index = 0; index < text.length; index++) {
-        const current = text[index];
-        if (current === '\\' && inString && index + 1 < text.length) {
-            index++;
-        } else if (current === '"' && !inTemplate) {
-            inString = !inString;
-        } else if (current === '`' && !inString) {
-            inTemplate = !inTemplate;
-        } else if (!inString && !inTemplate && current === '/' && text[index + 1] === '/') {
-            return text.slice(0, index);
-        }
-    }
-
-    return text;
-}
-
-// The `file` directive on a single line, or undefined when the line is not one. Callers that scan a
-// whole document go through fileReferences instead, so code fences are accounted for.
-export function fileReferenceOn(line: string, lineIndex: number): FileReference | undefined {
-    const indent = indentOf(line);
-    const content = withoutComment(line.slice(indent)).trimEnd();
-    if (firstWord(content) !== fileReferenceKeyword) return undefined;
-
-    const afterKeyword = content.slice(fileReferenceKeyword.length);
-    const path = afterKeyword.trim();
-
-    // A bare `file` leaves the word available as a name to whatever the enclosing block reads a bare
-    // word as, and a bare identifier after it is a property type rather than a path.
-    if (path.length === 0 || typeReferencePattern.test(path)) return undefined;
-
-    const separatorLength = afterKeyword.length - afterKeyword.trimStart().length;
-    const startColumn = indent + fileReferenceKeyword.length + separatorLength + 1;
-    return { path, line: lineIndex, startColumn, endColumn: startColumn + path.length };
-}
-
-// Every `file` directive in a document, in document order. Lines inside a code fence are skipped, so
-// a `file` line in an inline C# or TypeScript block is never mistaken for one of ours.
-export function fileReferences(lines: string[]): FileReference[] {
-    const fences = fenceMap(lines);
-    const references: FileReference[] = [];
-
-    for (let index = 0; index < lines.length; index++) {
-        if (fences[index]) continue;
-        const reference = fileReferenceOn(lines[index], index);
-        if (reference) references.push(reference);
-    }
-
-    return references;
-}

package/for_documentContext/when_stripping_comments.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 { describe, expect, it } from 'vitest';
-import { enclosingChain, fenceMap, nearestEnclosingLine, withoutComment } from '../document-context';
-
-// The same cases are asserted against C# SourceLineSplitter in when_stripping_comments.cs.
-const cases = [
-    ['value = path // comment', 'value = path'],
-    ['value = "https://example" // comment', 'value = "https://example"'],
-    [String.raw`value = "escaped \" // retained" // comment`, String.raw`value = "escaped \" // retained"`],
-    [String.raw`value = "ending \\" // comment`, String.raw`value = "ending \\"`],
-    ['value = `https://example` // comment', 'value = `https://example`'],
-    ['value = `a " // retained` // comment', 'value = `a " // retained`'],
-    ['value = "a ` // retained" // comment', 'value = "a ` // retained"'],
-    ['value = "unclosed // retained', 'value = "unclosed // retained'],
-    ['value = `unclosed // retained', 'value = `unclosed // retained'],
-    ['value = path # not a comment', 'value = path # not a comment'],
-    ["value = 'single // comment", "value = 'single"],
-];
-
-describe('when stripping structural comments', () => {
-    it.each(cases)('should match SourceLineSplitter for %s', (line, expected) => {
-        withoutComment(line).trimEnd().should.equal(expected);
-    });
-
-    it('should skip comment-only lines when finding an enclosing block', () => {
-        const lines = ['command Register // explanation', '  // comment', '    produces Registered'];
-        enclosingChain(lines, fenceMap(lines), 2, 4).should.deep.equal(['command']);
-        expect(nearestEnclosingLine(lines, fenceMap(lines), 2, 4)).toBe('command Register');
-    });
-});

package/for_eventContext/when_resolving_generated_catalog_vectors.ts

@@ -1,15 +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 { describe, expect, it } from 'vitest';
-import vectors from '../event-context-resolution-vectors.json';
-import { resolveEventContextPath } from '../event-context';
-
-describe('when resolving paths generated from the C# event-context catalog', () => {
-    it('agrees with C# on every known, missing and invalid path', () => {
-        expect(vectors.length).toBeGreaterThan(50);
-        for (const vector of vectors) {
-            expect(resolveEventContextPath(vector.path).status, vector.path).toBe(vector.status);
-        }
-    });
-});

package/for_eventGenerations/when_editing_event_generations.ts

@@ -1,57 +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 { describe, it } from 'vitest';
-import type { editor, languages, Position } from 'monaco-editor';
-import { createCompletionProvider } from '../completions';
-import type { Monaco } from '../language';
-import { createTokensProvider } from '../tokens';
-import { hoverContent } from '../hover-content';
-import { scanDocument } from '../symbols';
-
-const lines = [
-    'event Registered generation 1',
-    '  old String',
-    'event Registered generation 2',
-    '  generation String',
-    '  current String',
-    '  note = $eventContext.eventType.generation',
-];
-
-describe('when editing event generations', () => {
-    it('should recognize the marker only on a complete event header', () => {
-        const rules = createTokensProvider([]).tokenizer.root;
-        const headerRule = rules.find((rule) => Array.isArray(rule) && rule[0] instanceof RegExp && rule[0].source.includes('(generation)')) as [RegExp, string[]];
-        headerRule.should.not.be.undefined;
-        const header = lines[2].match(headerRule[0]);
-        header?.[6].should.equal('generation');
-        headerRule[1][5].should.equal('keyword');
-        lines.slice(3).every((line) => !headerRule[0].test(line)).should.be.true;
-    });
-
-    it('should keep generation as a property name', () => {
-        scanDocument(lines).events[1].properties.map((property) => property.name).should.include('generation');
-    });
-
-    it('should offer one completion per event name', () => {
-        const source = [...lines.slice(0, 5), 'command Send', '  produces '];
-        const model = {
-            getLinesContent: () => source,
-            getWordUntilPosition: () => ({ startColumn: 12, endColumn: 12 }),
-        } as unknown as editor.ITextModel;
-        const monaco = {
-            Range: class { constructor(..._args: number[]) {} },
-            languages: { CompletionItemKind: { Event: 1 }, CompletionItemInsertTextRule: { InsertAsSnippet: 4 } },
-        } as unknown as Monaco;
-        const provider = createCompletionProvider(monaco);
-        const result = provider.provideCompletionItems!(model, { lineNumber: 7, column: 12 } as Position, {} as languages.CompletionContext, {} as never) as languages.CompletionList;
-        result.suggestions.filter((item) => item.label === 'Registered').length.should.equal(1);
-    });
-
-    it('should hover over the generation declaration itself', () => {
-        const hover = hoverContent(lines, 2, 'Registered', 7, 17);
-        hover?.should.include('event Registered generation 2');
-        hover?.should.include('current String');
-        hover?.should.not.include('old String');
-    });
-});

package/for_fileImports/when_finding_file_imports.ts

@@ -1,38 +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 { describe, beforeEach, it } from 'vitest';
-import { FileImport, fileImportOn, fileImports, isFileImportLine } from '../file-imports';
-
-describe('when finding file imports', () => {
-    let found: FileImport[];
-
-    beforeEach(() => {
-        found = fileImports([
-            'import Customers.CustomerRegistered',
-            'import "**/*.play"',
-            'module Ordering',
-            '  import   "Orders/*.play" // the orders',
-            '  screen Overview',
-            '    ```typescript',
-            'import "not/a/play/import"',
-            '    ```',
-        ]);
-    });
-
-    it('should find the quoted imports outside code fences', () => {
-        found.map((each) => each.pattern).should.deep.equal(['**/*.play', 'Orders/*.play']);
-    });
-
-    it('should locate the pattern between the quotes', () => {
-        found[1].should.deep.equal({ pattern: 'Orders/*.play', line: 3, startColumn: 13, endColumn: 26 });
-    });
-
-    it('should not read a malformed import as one', () => {
-        (fileImportOn('import "a\\b.play"', 0) === undefined).should.be.true;
-    });
-
-    it('should tell a file import from a qualified one by its quote', () => {
-        [isFileImportLine('  import "x'), isFileImportLine('import X.Y')].should.deep.equal([true, false]);
-    });
-});

package/for_fileReferences/when_recognizing_an_absolute_path/with_paths_of_every_shape.ts

@@ -1,26 +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 { describe, it } from 'vitest';
-import { isAbsoluteFileReferencePath } from '../../file-references';
-
-// A reference is relative to the repository root, so it means the same thing on every machine. An
-// absolute one names a place on one machine and is wrong without looking anything up.
-describe('when recognizing an absolute path', () => {
-    it('should recognize a posix path', () => {
-        isAbsoluteFileReferencePath('/Users/someone/Invoices/Register.cs').should.be.true;
-    });
-
-    it('should recognize a windows path', () => {
-        isAbsoluteFileReferencePath('C:/repos/Invoices/Register.cs').should.be.true;
-        isAbsoluteFileReferencePath('C:\\repos\\Invoices\\Register.cs').should.be.true;
-    });
-
-    it('should recognize a home-relative path', () => {
-        isAbsoluteFileReferencePath('~/repos/Invoices/Register.cs').should.be.true;
-    });
-
-    it('should not recognize a repository-relative path', () => {
-        isAbsoluteFileReferencePath('Invoices/Register.cs').should.be.false;
-    });
-});

package/for_fileReferences/when_scanning_a_document/inside_a_code_fence.ts

@@ -1,26 +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 { describe, beforeEach, it } from 'vitest';
-import { FileReference, fileReferences } from '../../file-references';
-
-// An inline C# block may well contain the word `file` at the start of a line — it is a C# modifier —
-// and none of it is Screenplay.
-describe('when scanning a document with a file line inside a code fence', () => {
-    let result: FileReference[];
-
-    beforeEach(() => {
-        result = fileReferences([
-            'handler',
-            '    ```csharp',
-            '    file static class Helpers/NotAPath.cs',
-            '    ```',
-            '    file Handlers/Real.cs',
-        ]);
-    });
-
-    it('should find only the reference outside the fence', () => {
-        result.should.have.lengthOf(1);
-        result[0].path.should.equal('Handlers/Real.cs');
-    });
-});

package/for_fileReferences/when_scanning_a_document/with_a_bare_file_keyword.ts

@@ -1,19 +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 { describe, beforeEach, it } from 'vitest';
-import { FileReference, fileReferences } from '../../file-references';
-
-// A bare `file` carries no path, so it leaves the word available as a name to whatever the enclosing
-// block reads a bare word as.
-describe('when scanning a document with a bare file keyword', () => {
-    let result: FileReference[];
-
-    beforeEach(() => {
-        result = fileReferences(['reaction', '    file', '    file   ', 'filename Something.cs']);
-    });
-
-    it('should find no reference', () => {
-        result.should.be.empty;
-    });
-});