Function createZModelLanguageServices

packages/language/src/module.ts:94–148

(
    context: DefaultSharedModuleContext,
    logToConsole = false,
)

 * @returns An object wrapping the shared services and the language-specific services
 */
export function createZModelLanguageServices(
    context: DefaultSharedModuleContext,
    logToConsole = false,
): {
    shared: LangiumSharedServices;
    ZModelLanguage: ZModelServices;
} {
    const shared = inject(createDefaultSharedModule(context), ZModelGeneratedSharedModule, ZModelSharedModule);
    const ZModelLanguage = inject(createDefaultModule({ shared }), ZModelGeneratedModule, ZModelLanguageModule);
    shared.ServiceRegistry.register(ZModelLanguage);
    registerValidationChecks(ZModelLanguage);
    if (!context.connection) {
        // We don't run inside a language server
        // Therefore, initialize the configuration provider instantly
        shared.workspace.ConfigurationProvider.initialized({});
    }

    // when documents reach Parsed state, inspect plugin declarations and load corresponding
    // plugin zmodel docs
    // Note we must use `onBuildPhase` instead of `onDocumentPhase` here because the latter is
    // not called when not running inside a language server.
    shared.workspace.DocumentBuilder.onBuildPhase(DocumentState.Parsed, async (documents) => {
        for (const doc of documents) {
            if (doc.parseResult.lexerErrors.length > 0 || doc.parseResult.parserErrors.length > 0) {
                // balk if there are lexer or parser errors
                continue;
            }

            if (doc.uri.scheme !== 'file') {
                continue;
            }

            const schemaPath = fileURLToPath(doc.uri.toString());
            const pluginSchemas = getPluginDocuments(doc.parseResult.value as Model, schemaPath);

            // ensure plugin docs are loaded
            for (const plugin of pluginSchemas) {
                const pluginDocUri = URI.file(path.resolve(plugin));
                let pluginDoc = shared.workspace.LangiumDocuments.getDocument(pluginDocUri);
                if (!pluginDoc) {
                    pluginDoc = await shared.workspace.LangiumDocuments.getOrCreateDocument(pluginDocUri);
                    if (pluginDoc) {
                        // add to indexer so the plugin model's definitions are globally visible
                        shared.workspace.IndexManager.updateContent(pluginDoc);
                        if (logToConsole) {
                            console.log(`Loaded plugin model: ${plugin}`);
                        }
                    }
                }
            }
        }
    });

    return { shared, ZModelLanguage };
}

// TODO: proper logging system
export function createZModelServices(logToConsole = false) {