@reqlan/language 1.4.0

package/src/reqlan-inbound-reference-inlay-label.ts

@@ -0,0 +1,194 @@
+/**
+ * Formats inbound reference lists for idea declaration inlay hints.
+ */
+import { AstUtils, GrammarUtils, type AstNode } from 'langium';
+import {
+    Command,
+    InlayHintLabelPart,
+    Location,
+    MarkupKind,
+    type InlayHintLabelPart as InlayHintLabelPartType,
+    type MarkupContent
+} from 'vscode-languageserver';
+import { isIdea, isIdeaSet, isOneLinerIdea, type IdeaDeclaration, type IdeaSet } from './generated/ast.js';
+import { REQLAN_INBOUND_REFERENCES_SUMMARY_COMMAND } from './reqlan-inlay-hint-settings.js';
+import type { ReqlanServices } from './reqlan-module.js';
+
+export interface InboundReferenceInlayLabel {
+    labelParts: InlayHintLabelPartType[];
+    tooltip?: MarkupContent;
+}
+
+export interface InboundReferencer {
+    name: string;
+    location: Location;
+}
+
+export type ReferencedDeclaration = IdeaDeclaration | IdeaSet;
+
+const MAX_INLINE_NAMES = 3;
+
+/**
+ * Collect inbound idea referencers from the whole Langium workspace index
+ * (every indexed `.rq` document), not only the declaration's file.
+ */
+export function collectInboundReferencers(
+    services: ReqlanServices,
+    declaration: ReferencedDeclaration
+): InboundReferencer[] {
+    const documents = services.shared.workspace.LangiumDocuments;
+    const locator = services.workspace.AstNodeLocator;
+    const referencers = new Map<string, InboundReferencer>();
+
+    // findReferences without documentUri walks IndexManager across the workspace.
+    for (const reference of services.references.References.findReferences(declaration, { includeDeclaration: false }).toArray()) {
+        const sourceDocument = documents.getDocument(reference.sourceUri);
+        if (!sourceDocument) {
+            continue;
+        }
+        const sourceNode = locator.getAstNode(sourceDocument.parseResult.value, reference.sourcePath);
+        if (!sourceNode) {
+            continue;
+        }
+        const referrer = enclosingReferrerDeclaration(sourceNode);
+        if (!referrer || isSameDeclaration(referrer, declaration)) {
+            continue;
+        }
+        const location = locationForReferrer(referrer);
+        if (!location) {
+            continue;
+        }
+        referencers.set(locationKey(location), {
+            name: referrer.name,
+            location
+        });
+    }
+
+    return [...referencers.values()].sort((left, right) => left.name.localeCompare(right.name));
+}
+
+/** @deprecated Use {@link collectInboundReferencers} */
+export function collectInboundReferencingNames(
+    services: ReqlanServices,
+    declaration: ReferencedDeclaration
+): string[] {
+    return collectInboundReferencers(services, declaration).map(referrer => referrer.name);
+}
+
+function enclosingReferrerDeclaration(node: AstNode): ReferencedDeclaration | undefined {
+    let current: AstNode | undefined = node;
+    while (current) {
+        if (isIdea(current) || isOneLinerIdea(current) || isIdeaSet(current)) {
+            return current;
+        }
+        current = current.$container;
+    }
+    return undefined;
+}
+
+function isSameDeclaration(left: ReferencedDeclaration, right: ReferencedDeclaration): boolean {
+    if (left === right) {
+        return true;
+    }
+    if (left.name !== right.name) {
+        return false;
+    }
+    return AstUtils.getDocument(left).uri.toString() === AstUtils.getDocument(right).uri.toString();
+}
+
+function locationForReferrer(referrer: ReferencedDeclaration): Location | undefined {
+    const nameNode = GrammarUtils.findNodeForProperty(referrer.$cstNode, 'name');
+    if (!nameNode?.range) {
+        return undefined;
+    }
+    const document = AstUtils.getDocument(referrer);
+    return Location.create(document.textDocument.uri, nameNode.range);
+}
+
+function locationKey(location: Location): string {
+    const range = location.range;
+    return `${location.uri}#${range.start.line}:${range.start.character}`;
+}
+
+export function referencerMarkdownLink(referrer: InboundReferencer): string {
+    const line = referrer.location.range.start.line + 1;
+    const character = referrer.location.range.start.character + 1;
+    return `[${referrer.name}](${referrer.location.uri}#L${line},${character})`;
+}
+
+export function buildReferencersTooltipMarkup(referencers: InboundReferencer[]): MarkupContent {
+    const items = referencers.map(referrer => `- ${referencerMarkdownLink(referrer)}`).join('\n');
+    return {
+        kind: MarkupKind.Markdown,
+        value: `**Referenced by**\n\n${items}`
+    };
+}
+
+function referencerPartTooltip(referrer: InboundReferencer): MarkupContent {
+    return {
+        kind: MarkupKind.Markdown,
+        value: referencerMarkdownLink(referrer)
+    };
+}
+
+export function buildInboundReferencesInlayLabel(
+    referencers: InboundReferencer[],
+    targetDocumentUri: string,
+    targetName: string
+): InboundReferenceInlayLabel | undefined {
+    if (referencers.length === 0) {
+        return undefined;
+    }
+    const tooltip = buildReferencersTooltipMarkup(referencers);
+    const inlineReferencers = referencers.slice(0, MAX_INLINE_NAMES);
+    const remainder = referencers.length - inlineReferencers.length;
+    const labelParts: InlayHintLabelPartType[] = [
+        InlayHintLabelPart.create('@referenced-by: (')
+    ];
+
+    for (let index = 0; index < inlineReferencers.length; index++) {
+        if (index > 0) {
+            labelParts.push(InlayHintLabelPart.create(', '));
+        }
+        labelParts.push({
+            value: inlineReferencers[index].name,
+            location: inlineReferencers[index].location,
+            tooltip: referencerPartTooltip(inlineReferencers[index])
+        });
+    }
+
+    if (remainder > 0) {
+        labelParts.push(InlayHintLabelPart.create(', '));
+        labelParts.push({
+            value: `+${remainder} more`,
+            tooltip,
+            command: Command.create(
+                'Show all inbound references',
+                REQLAN_INBOUND_REFERENCES_SUMMARY_COMMAND,
+                targetDocumentUri,
+                targetName
+            )
+        });
+    }
+
+    labelParts.push(InlayHintLabelPart.create(')'));
+
+    return {
+        labelParts,
+        tooltip
+    };
+}
+
+/** @deprecated Use {@link buildInboundReferencesInlayLabel} */
+export function formatInboundReferencesInlayLabel(referencers: string[]): { label: string; tooltip?: string } | undefined {
+    if (referencers.length === 0) {
+        return undefined;
+    }
+    const inlineNames = referencers.slice(0, MAX_INLINE_NAMES);
+    const remainder = referencers.length - inlineNames.length;
+    const suffix = remainder > 0 ? `, +${remainder} more` : '';
+    return {
+        label: `@referenced-by: (${inlineNames.join(', ')}${suffix})`,
+        tooltip: referencers.join('\n')
+    };
+}

package/src/reqlan-inlay-hint-provider.ts

@@ -0,0 +1,88 @@
+/**
+ * Inlay hints showing inbound references on idea declarations as a computed attribute.
+ */
+import { AstUtils, GrammarUtils, type AstNode, type LangiumDocument } from 'langium';
+import { AbstractInlayHintProvider } from 'langium/lsp';
+import type { CancellationToken } from 'vscode-languageserver';
+import { InlayHintKind, type InlayHint, type InlayHintParams } from 'vscode-languageserver';
+import {
+    isIdea,
+    isIdeaSet,
+    isOneLinerIdea
+} from './generated/ast.js';
+import {
+    buildInboundReferencesInlayLabel,
+    collectInboundReferencers,
+    type ReferencedDeclaration
+} from './reqlan-inbound-reference-inlay-label.js';
+import {
+    REQLAN_REFERENCE_INLAY_HINTS_SETTING,
+    referenceInlayHintsEnabled,
+    type ReferenceInlayHintsSettings
+} from './reqlan-inlay-hint-settings.js';
+import type { ReqlanServices } from './reqlan-module.js';
+
+export class ReqlanInlayHintProvider extends AbstractInlayHintProvider {
+
+    private readonly services: ReqlanServices;
+
+    constructor(services: ReqlanServices) {
+        super();
+        this.services = services;
+    }
+
+    override async getInlayHints(
+        document: LangiumDocument,
+        params: InlayHintParams,
+        cancelToken?: CancellationToken
+    ): Promise<InlayHint[] | undefined> {
+        const settings = await this.services.shared.workspace.ConfigurationProvider.getConfiguration(
+            'reqlan',
+            REQLAN_REFERENCE_INLAY_HINTS_SETTING
+        ) as ReferenceInlayHintsSettings | undefined;
+        if (!referenceInlayHintsEnabled(settings)) {
+            return [];
+        }
+        return super.getInlayHints(document, params, cancelToken);
+    }
+
+    computeInlayHint(node: AstNode, acceptor: (hint: InlayHint) => void): void {
+        if (isIdea(node) || isOneLinerIdea(node)) {
+            this.acceptInboundReferenceHint(node, acceptor);
+            return;
+        }
+        if (isIdeaSet(node)) {
+            this.acceptInboundReferenceHint(node, acceptor);
+        }
+    }
+
+    private acceptInboundReferenceHint(
+        declaration: ReferencedDeclaration,
+        acceptor: (hint: InlayHint) => void
+    ): void {
+        const nameNode = GrammarUtils.findNodeForProperty(declaration.$cstNode, 'name');
+        if (!nameNode?.range) {
+            return;
+        }
+        const referencers = collectInboundReferencers(this.services, declaration);
+        const document = AstUtils.getDocument(declaration);
+        const formatted = buildInboundReferencesInlayLabel(
+            referencers,
+            document.textDocument.uri,
+            declaration.name
+        );
+        if (!formatted) {
+            return;
+        }
+        acceptor({
+            position: {
+                line: nameNode.range.end.line,
+                character: nameNode.range.end.character
+            },
+            label: formatted.labelParts,
+            tooltip: formatted.tooltip,
+            kind: InlayHintKind.Type,
+            paddingLeft: true
+        });
+    }
+}

package/src/reqlan-inlay-hint-settings.ts

@@ -0,0 +1,15 @@
+/**
+ * Workspace settings for reference inlay hints.
+ */
+export const REQLAN_REFERENCE_INLAY_HINTS_SETTING = 'referencesInlayHints';
+
+/** VS Code command invoked when clicking "+N more" on an inbound-reference inlay hint. */
+export const REQLAN_INBOUND_REFERENCES_SUMMARY_COMMAND = 'reqlan.openInboundReferencesSummary';
+
+export interface ReferenceInlayHintsSettings {
+    enabled?: boolean;
+}
+
+export function referenceInlayHintsEnabled(settings: ReferenceInlayHintsSettings | undefined): boolean {
+    return settings?.enabled === true;
+}

package/src/reqlan-linker.ts

@@ -0,0 +1,108 @@
+/**
+ * Links anonymous qualified import paths without requiring a matching import declaration,
+ * and keeps bare namespace-alias references unlinked instead of reporting them as unresolved ideas.
+ * rq:["../../../reqlan rq/language/imports.rq".import_namespace]
+ */
+import type { AstNode, FileSystemProvider, LangiumDocument, LangiumDocuments, ReferenceInfo } from 'langium';
+import { AstUtils, DefaultLinker, type DefaultReference } from 'langium';
+import { isLocalReference, isModel, isQualifiedReference } from './generated/ast.js';
+import { isOpaqueFileReferencePath } from './reqlan-file-references.js';
+import { findNamespaceImportByAlias } from './reqlan-import-bindings.js';
+import { isResolvableImportPath } from './reqlan-imports.js';
+import type { ReqlanServices } from './reqlan-module.js';
+import { pathResolveContextFromServices } from './reqlan-path-resolve.js';
+import { unquoteReqlanString } from './reqlan-references.js';
+
+/** Marks a reference that resolves to a file rather than to an AST node. */
+export const UnlinkedFileTarget = Symbol('UnlinkedFileTarget');
+
+export class ReqlanLinker extends DefaultLinker {
+
+    private readonly documents: LangiumDocuments;
+    private readonly fileSystem: FileSystemProvider;
+    private readonly services: ReqlanServices;
+
+    constructor(services: ReqlanServices) {
+        super(services);
+        this.documents = services.shared.workspace.LangiumDocuments;
+        this.fileSystem = services.shared.workspace.FileSystemProvider;
+        this.services = services;
+    }
+
+    protected override doLink(refInfo: ReferenceInfo, document: LangiumDocument): void {
+        if (this.isAnonymousImportPathReference(refInfo)) {
+            const scope = this.scopeProvider.getScope(refInfo);
+            if (scope.getElement(refInfo.reference.$refText)) {
+                super.doLink(refInfo, document);
+                return;
+            }
+            const path = unquoteReqlanString(refInfo.reference.$refText);
+            if (isOpaqueFileReferencePath(path)) {
+                return;
+            }
+            if (this.resolvesAnonymousImportPath(path, document)) {
+                this.markUnlinked(refInfo, document);
+                return;
+            }
+        }
+        if (this.isNamespaceAliasReference(refInfo)) {
+            this.markUnlinked(refInfo, document);
+            return;
+        }
+        super.doLink(refInfo, document);
+    }
+
+    /**
+     * `[alias]` on its own targets the imported file, not an idea inside it. The check stays syntactic
+     * because reading `ref` here would resolve the reference and record the linking error we avoid.
+     */
+    private isNamespaceAliasReference(refInfo: ReferenceInfo): boolean {
+        const container = refInfo.container;
+        if (!isLocalReference(container)) {
+            return false;
+        }
+        if (refInfo.property !== 'idea') {
+            return false;
+        }
+        const model = AstUtils.getDocument(container).parseResult.value;
+        if (!isModel(model)) {
+            return false;
+        }
+        const name = refInfo.reference.$refText;
+        if (model.elements.some(element => element.name === name)) {
+            return false;
+        }
+        return findNamespaceImportByAlias(model.imports, name) !== undefined;
+    }
+
+    protected override resolveReference(reference: DefaultReference, node: AstNode, property: string): AstNode | undefined {
+        if ((reference as { _ref?: unknown })._ref === UnlinkedFileTarget) {
+            return undefined;
+        }
+        return super.resolveReference(reference, node, property);
+    }
+
+    private isAnonymousImportPathReference(refInfo: ReferenceInfo): boolean {
+        return isQualifiedReference(refInfo.container)
+            && refInfo.property === 'path'
+            && refInfo.container.path === refInfo.reference;
+    }
+
+    private resolvesAnonymousImportPath(path: string, document: LangiumDocument): boolean {
+        return isResolvableImportPath(
+            path,
+            document,
+            this.documents,
+            this.fileSystem,
+            pathResolveContextFromServices(this.services)
+        );
+    }
+
+    private markUnlinked(refInfo: ReferenceInfo, document: LangiumDocument): void {
+        const ref = refInfo.reference;
+        if ('_ref' in ref && ref._ref === undefined) {
+            ref._ref = UnlinkedFileTarget;
+            document.references.push(ref);
+        }
+    }
+}

package/src/reqlan-markdown-links.ts

@@ -0,0 +1,136 @@
+/**
+ * Helpers for markdown-style links `[label](target)` in requirement prose.
+ */
+import type { CstNode, LangiumDocument } from 'langium';
+import { CstUtils } from 'langium';
+import type { Position } from 'vscode-languageserver';
+import { isMarkdownLink } from './generated/ast.js';
+import { parseMarkdownLink } from './reqlan-references.js';
+
+const MARKDOWN_LINK_IN_TEXT_PATTERN = /\[([^\]]+)\]\(([^)]+)\)/g;
+
+export function markdownLinkLabelRange(raw: string, linkOffset: number): { start: number; end: number } | undefined {
+    const parsed = parseMarkdownLink(raw);
+    if (!parsed) {
+        return undefined;
+    }
+    return {
+        start: linkOffset + 1,
+        end: linkOffset + 1 + parsed.label.length
+    };
+}
+
+export function markdownLinkTargetRange(raw: string, linkOffset: number): { start: number; end: number } | undefined {
+    const parsed = parseMarkdownLink(raw);
+    if (!parsed) {
+        return undefined;
+    }
+    const targetStart = raw.indexOf('](') + 2;
+    return {
+        start: linkOffset + targetStart,
+        end: linkOffset + targetStart + parsed.target.length
+    };
+}
+
+export function isOffsetInsideRange(offset: number, start: number, end: number): boolean {
+    return offset >= start && offset < end;
+}
+
+export function isMarkdownLinkLabelPosition(document: LangiumDocument, position: Position): boolean {
+    const offset = document.textDocument.offsetAt(position);
+    const root = document.parseResult.value.$cstNode;
+    if (root) {
+        const leaf = CstUtils.findLeafNodeAtOffset(root, offset);
+        let current: CstNode | undefined = leaf;
+        while (current) {
+            if (isMarkdownLink(current.astNode)) {
+                const labelRange = markdownLinkLabelRange(current.astNode.raw, current.offset);
+                if (labelRange && isOffsetInsideRange(offset, labelRange.start, labelRange.end)) {
+                    return true;
+                }
+                return false;
+            }
+            current = current.container;
+        }
+    }
+    return isMarkdownLinkLabelOffsetInText(document.textDocument.getText(), offset);
+}
+
+export function isMarkdownLinkTargetPosition(document: LangiumDocument, position: Position): boolean {
+    const offset = document.textDocument.offsetAt(position);
+    const root = document.parseResult.value.$cstNode;
+    if (!root) {
+        return false;
+    }
+    const leaf = CstUtils.findLeafNodeAtOffset(root, offset);
+    let current: CstNode | undefined = leaf;
+    while (current) {
+        if (isMarkdownLink(current.astNode)) {
+            const targetRange = markdownLinkTargetRange(current.astNode.raw, current.offset);
+            return targetRange ? isOffsetInsideRange(offset, targetRange.start, targetRange.end) : false;
+        }
+        current = current.container;
+    }
+    return false;
+}
+
+export function isMarkdownLinkLabelOffsetInText(text: string, offset: number): boolean {
+    for (const span of iterateMarkdownLinkSpans(text)) {
+        if (isOffsetInsideRange(offset, span.labelStart, span.labelEnd)) {
+            return true;
+        }
+    }
+    return false;
+}
+
+export function isRangeInsideMarkdownLinkLabel(text: string, start: number, end: number): boolean {
+    for (const span of iterateMarkdownLinkSpans(text)) {
+        if (start >= span.labelStart && end <= span.labelEnd) {
+            return true;
+        }
+    }
+    return false;
+}
+
+export interface MarkdownLinkSpan {
+    rawStart: number;
+    rawEnd: number;
+    labelStart: number;
+    labelEnd: number;
+    targetStart: number;
+    targetEnd: number;
+}
+
+export function iterateMarkdownLinkSpans(text: string): MarkdownLinkSpan[] {
+    const spans: MarkdownLinkSpan[] = [];
+    MARKDOWN_LINK_IN_TEXT_PATTERN.lastIndex = 0;
+    let match: RegExpExecArray | null;
+    while ((match = MARKDOWN_LINK_IN_TEXT_PATTERN.exec(text)) !== null) {
+        const rawStart = match.index;
+        const labelStart = rawStart + 1;
+        const labelEnd = labelStart + match[1]!.length;
+        const targetStart = labelEnd + 2;
+        const targetEnd = targetStart + match[2]!.length;
+        spans.push({
+            rawStart,
+            rawEnd: targetEnd + 1,
+            labelStart,
+            labelEnd,
+            targetStart,
+            targetEnd
+        });
+    }
+    return spans;
+}
+
+export function linePrefixBeforeMarkdownLinkTarget(document: LangiumDocument, position: Position): boolean {
+    const linePrefix = document.textDocument.getText({
+        start: { line: position.line, character: 0 },
+        end: position
+    });
+    const afterCursor = document.textDocument.getText({
+        start: position,
+        end: { line: position.line, character: Number.MAX_SAFE_INTEGER }
+    });
+    return /\[[^\]]*$/.test(linePrefix) && /^\]\(/.test(afterCursor);
+}

package/src/reqlan-module.ts

@@ -0,0 +1,104 @@
+import { type Module, inject } from 'langium';
+import { createDefaultModule, createDefaultSharedModule, type DefaultSharedModuleContext, type LangiumServices, type LangiumSharedServices, type PartialLangiumServices } from 'langium/lsp';
+import { ReqlanGeneratedModule, ReqlanGeneratedSharedModule } from './generated/module.js';
+import { ReqlanDefinitionProvider } from './reqlan-definition-provider.js';
+import { ReqlanDocumentHighlightProvider } from './reqlan-document-highlight-provider.js';
+import { ReqlanDocumentLinkProvider } from './reqlan-document-link-provider.js';
+import { createReqlanGrammarConfig } from './reqlan-grammar-config.js';
+import { ReqlanNameProvider } from './reqlan-name-provider.js';
+import { ReqlanLinker } from './reqlan-linker.js';
+import { ReqlanScopeComputation, ReqlanScopeProvider } from './reqlan-scope.js';
+import { ReqlanCompletionProvider } from './reqlan-completion-provider.js';
+import { ReqlanCodeActionProvider } from './reqlan-code-action-provider.js';
+import { sharedAttributeCatalog } from './reqlan-attribute-catalog.js';
+import { ReqlanCodeLensProvider } from './reqlan-code-lens-provider.js';
+import { ReqlanInlayHintProvider } from './reqlan-inlay-hint-provider.js';
+import { ReqlanSemanticTokenProvider } from './reqlan-semantic-token-provider.js';
+import { ReqlanTokenBuilder } from './reqlan-token-builder.js';
+import { registerRqIgnoreErrorFiltering } from './reqlan-ignore-error.js';
+import { ReqlanValidator, registerValidationChecks } from './reqlan-validator.js';
+
+/**
+ * Declaration of custom services - add your own service classes here.
+ */
+export type ReqlanAddedServices = {
+    validation: {
+        ReqlanValidator: ReqlanValidator
+    }
+}
+
+/**
+ * Union of Langium default services and your custom services - use this as constructor parameter
+ * of custom service classes.
+ */
+export type ReqlanServices = LangiumServices & ReqlanAddedServices
+
+/**
+ * Dependency injection module that overrides Langium default services and contributes the
+ * declared custom services. The Langium defaults can be partially specified to override only
+ * selected services, while the custom services must be fully specified.
+ */
+export const ReqlanModule: Module<ReqlanServices, PartialLangiumServices & ReqlanAddedServices> = {
+    validation: {
+        ReqlanValidator: services => new ReqlanValidator(services)
+    },
+    references: {
+        Linker: services => new ReqlanLinker(services),
+        NameProvider: () => new ReqlanNameProvider(),
+        ScopeComputation: services => new ReqlanScopeComputation(services),
+        ScopeProvider: services => new ReqlanScopeProvider(services)
+    },
+    parser: {
+        GrammarConfig: createReqlanGrammarConfig,
+        TokenBuilder: () => new ReqlanTokenBuilder()
+    },
+    lsp: {
+        DefinitionProvider: services => new ReqlanDefinitionProvider(services),
+        DocumentHighlightProvider: services => new ReqlanDocumentHighlightProvider(services),
+        DocumentLinkProvider: services => new ReqlanDocumentLinkProvider(services),
+        SemanticTokenProvider: services => new ReqlanSemanticTokenProvider(services),
+        InlayHintProvider: services => new ReqlanInlayHintProvider(services),
+        CodeLensProvider: services => new ReqlanCodeLensProvider(services),
+        CompletionProvider: services => new ReqlanCompletionProvider(services, sharedAttributeCatalog),
+        CodeActionProvider: services => new ReqlanCodeActionProvider(services)
+    }
+};
+
+/**
+ * Create the full set of services required by Langium.
+ *
+ * First inject the shared services by merging two modules:
+ *  - Langium default shared services
+ *  - Services generated by langium-cli
+ *
+ * Then inject the language-specific services by merging three modules:
+ *  - Langium default language-specific services
+ *  - Services generated by langium-cli
+ *  - Services specified in this file
+ *
+ * @param context Optional module context with the LSP connection
+ * @returns An object wrapping the shared services and the language-specific services
+ */
+export function createReqlanServices(context: DefaultSharedModuleContext): {
+    shared: LangiumSharedServices,
+    Reqlan: ReqlanServices
+} {
+    const shared = inject(
+        createDefaultSharedModule(context),
+        ReqlanGeneratedSharedModule
+    );
+    const Reqlan = inject(
+        createDefaultModule({ shared }),
+        ReqlanGeneratedModule,
+        ReqlanModule
+    );
+    shared.ServiceRegistry.register(Reqlan);
+    registerValidationChecks(Reqlan);
+    registerRqIgnoreErrorFiltering(shared);
+    if (!context.connection) {
+        // We don't run inside a language server
+        // Therefore, initialize the configuration provider instantly
+        shared.workspace.ConfigurationProvider.initialized({});
+    }
+    return { shared, Reqlan };
+}