npm - @oml/server - Versions diffs - 0.16.1 → 0.16.3 - Mend

@oml/server 0.16.1 → 0.16.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/out/rest/server.js +118 -25
package/out/rest/server.js.map +1 -1
package/out/rest/shell-index.d.ts +1 -0
package/out/rest/shell-index.js +795 -0
package/out/rest/shell-index.js.map +1 -0
package/out/rest/template.js +0 -3
package/out/rest/template.js.map +1 -1
package/out/workspace-settings.d.ts +6 -0
package/out/workspace-settings.js.map +1 -1
package/package.json +4 -4

package/out/rest/server.js CHANGED Viewed

@@ -22,6 +22,8 @@ import { createOpenApiSpec, dispatchRestOperation, resolveRestOperationId } from
 import { buildTemplateCatalog, expandTemplateComposeBlocks, findFilesByExtension, frontMatterString, isTemplateMarkdownFile, normalizeContextOntologyIri, } from './template.js';
 import { lintWorkspace, validateWorkspace } from './validation.js';
 import { reindexWorkspaceShacl } from './shacl-index.js';
+import { generateShellIndex } from './shell-index.js';
+import { readWorkspaceSettings } from '../workspace-settings.js';
 import { OmlAccessError, requiredFeatureForRestOperation, } from '../auth/feature-policy.js';
 const JSON_CONTENT_TYPE = 'application/json; charset=utf-8';
 const HTML_CONTENT_TYPE = 'text/html; charset=utf-8';
@@ -1671,6 +1673,38 @@ function toMdBlockKind(language) {
     return SUPPORTED_MD_BLOCK_KINDS.has(language) ? language : undefined;
 }
 const SCRIPT_LANGUAGES = new Set(['javascript', 'js', 'python', 'r']);
+function extractScriptIncludePaths(code) {
+    const re = /\binclude\s*\(\s*(?:"((?:[^"\\]|\\[\s\S])*)"|'((?:[^'\\]|\\[\s\S])*)'|`((?:[^`\\]|\\[\s\S])*)`)\s*\)/g;
+    const seen = new Set();
+    let m;
+    while ((m = re.exec(code)) !== null) {
+        seen.add(m[1] ?? m[2] ?? m[3]);
+    }
+    return [...seen];
+}
+async function buildScriptIncludeCache(codeBlocks, workspaceRoot) {
+    const allPaths = new Set();
+    for (const block of codeBlocks) {
+        if (!SCRIPT_LANGUAGES.has(block.language)) {
+            continue;
+        }
+        for (const p of extractScriptIncludePaths(block.content)) {
+            allPaths.add(p);
+        }
+    }
+    const cache = {};
+    await Promise.all([...allPaths].map(async (p) => {
+        try {
+            const abs = path.resolve(workspaceRoot, p);
+            const rel = path.relative(workspaceRoot, abs);
+            if (!rel.startsWith('..') && !path.isAbsolute(rel)) {
+                cache[p] = await fs.readFile(abs, 'utf-8');
+            }
+        }
+        catch { /* silently omit missing/unreadable files */ }
+    }));
+    return cache;
+}
 function extractScriptQueryStrings(code) {
     const seen = new Set();
     const patterns = [
@@ -1770,6 +1804,9 @@ function toRelativeWebPath(fromDir, toFile) {
     }
     return relative.startsWith('.') ? relative : `./${relative}`;
 }
+function contentRelPathForShell(shellRelPath) {
+    return path.posix.join('assets', 'pages', shellRelPath);
+}
 function isImagePath(filePath) {
     return /\.(png|jpe?g|gif|svg|webp|bmp|ico|avif)$/i.test(filePath);
 }
@@ -2117,7 +2154,7 @@ function buildIriAliasMapForPage(aliasesByIri, outputFile) {
     }
     return aliases;
 }
-function wrapHtml(content, runtimeScriptPath, stylesheetPath, blockManifest, blockResults, wikiLinkHrefByKey, iriAliasByIri, scriptSparqlCache) {
+function wrapHtml(content, runtimeScriptPath, stylesheetPath, blockManifest, blockResults, wikiLinkHrefByKey, iriAliasByIri, scriptSparqlCache, scriptIncludeCache) {
     const escapedManifest = escapeJsonForScript(JSON.stringify(blockManifest));
     const inlineResults = Object.fromEntries(blockResults.map((result) => [result.blockId, result]));
     const escapedInlineResults = escapeJsonForScript(JSON.stringify(inlineResults));
@@ -2125,10 +2162,12 @@ function wrapHtml(content, runtimeScriptPath, stylesheetPath, blockManifest, blo
     const escapedIriAliasIndex = escapeJsonForScript(JSON.stringify(iriAliasByIri));
     const escapedLinkingConfig = escapeJsonForScript(JSON.stringify({ linkingEnabled: true }));
     const escapedScriptCache = escapeJsonForScript(JSON.stringify(scriptSparqlCache));
+    const escapedIncludeCache = escapeJsonForScript(JSON.stringify(scriptIncludeCache));
     return `<!doctype html>
 <html lang="en">
 <head>
   <meta charset="UTF-8">
+  <base href="__OML_SHELL_BASE_HREF__" target="_top">
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>OML Markdown</title>
   <script>
@@ -2150,6 +2189,7 @@ function wrapHtml(content, runtimeScriptPath, stylesheetPath, blockManifest, blo
 <script id="oml-md-wikilink-config" type="application/json">${escapedLinkingConfig}</script>
 <script id="oml-md-member-labels" type="application/json">{}</script>
 <script id="oml-md-script-sparql-cache" type="application/json">${escapedScriptCache}</script>
+<script id="oml-md-script-include-cache" type="application/json">${escapedIncludeCache}</script>
 <script src="${escapeAttribute(runtimeScriptPath)}"></script>
 </body>
 </html>
@@ -2763,6 +2803,14 @@ class InMemoryJsonRpcLspClient {
     }
     async renderWorkspace(params) {
         await this.ensureInitialized();
+        const reasoningService = this.runtime.Oml.reasoning.ReasoningService;
+        const render = () => this.renderWorkspaceWithInitializedRuntime(params);
+        if (typeof reasoningService?.suppressSemanticChangeNotifications === 'function') {
+            return await reasoningService.suppressSemanticChangeNotifications(render);
+        }
+        return await render();
+    }
+    async renderWorkspaceWithInitializedRuntime(params) {
         await this.ensureWorkspaceSettled(false);
         const lint = await this.lintWorkspace({});
         if (lint.errors > 0 || lint.warnings > 0) {
@@ -2819,6 +2867,7 @@ class InMemoryJsonRpcLspClient {
         const workspaceAssetFiles = new Set();
         const aliasesByIri = new Map();
         const renderJobs = [];
+        const mdHtmlPaths = [];
         const contextModelUris = new Set();
         let filesRendered = 0;
         let blockArtifactFiles = 0;
@@ -2851,13 +2900,13 @@ class InMemoryJsonRpcLspClient {
             });
             const prepared = runtime.prepare(expandedMarkdown);
             const relative = path.relative(inputDir, markdownPath).replace(/\\/g, '/');
-            const htmlPath = path.join(outputDir, relative.replace(/\.md$/i, '.html'));
+            const shellPath = path.join(outputDir, relative.replace(/\.md$/i, '.html'));
             const rewriteResult = rewriteRenderedLinks(prepared.renderedHtml, {
                 workspaceRoot,
                 inputRoot: inputDir,
                 inputFile: markdownPath,
                 outputRoot: outputDir,
-                outputFile: htmlPath,
+                outputFile: shellPath,
             });
             for (const asset of rewriteResult.workspaceAssets) {
                 workspaceAssetFiles.add(asset);
@@ -2879,22 +2928,25 @@ class InMemoryJsonRpcLspClient {
                 inputRoot: inputDir,
                 sourceFile: markdownPath,
                 outputRoot: outputDir,
-                outputFile: htmlPath,
+                outputFile: shellPath,
             }, workspaceAssetFiles));
-            const blockArtifacts = await writeBlockArtifacts(htmlPath, rewrittenBlockResults);
+            const blockArtifacts = await writeBlockArtifacts(shellPath, rewrittenBlockResults);
             blockArtifactFiles += blockArtifacts.count;
-            const wikiLinkHrefByKey = buildWikiLinkHrefMapForPage(wikiPageIndex, htmlPath);
+            const wikiLinkHrefByKey = buildWikiLinkHrefMapForPage(wikiPageIndex, shellPath);
             const scriptSparqlCache = contextModelUri
                 ? await buildScriptSparqlCache(prepared.codeBlocks, (sparql) => reasoningService.getSparqlService().query(contextModelUri, sparql))
                 : {};
+            const scriptIncludeCache = await buildScriptIncludeCache(prepared.codeBlocks, workspaceRoot);
             renderJobs.push({
-                htmlPath,
+                shellPath,
                 renderedHtml: rewriteResult.html,
                 blockManifest: blockArtifacts.manifest,
                 blockResults: rewrittenBlockResults,
                 wikiLinkHrefByKey,
                 scriptSparqlCache,
+                scriptIncludeCache,
             });
+            mdHtmlPaths.push(shellPath);
             filesRendered += 1;
         }
         const renderedNavigationPages = new Set();
@@ -2907,15 +2959,15 @@ class InMemoryJsonRpcLspClient {
                 if (!resolution.template) {
                     continue;
                 }
-                const targetFile = memberIriToOutputFile(outputDir, memberIri);
-                if (!targetFile) {
+                const targetShellFile = memberIriToOutputFile(outputDir, memberIri);
+                if (!targetShellFile) {
                     continue;
                 }
-                aliasesByIri.set(memberIri, targetFile);
-                if (renderedNavigationPages.has(targetFile)) {
+                aliasesByIri.set(memberIri, targetShellFile);
+                if (renderedNavigationPages.has(targetShellFile)) {
                     continue;
                 }
-                renderedNavigationPages.add(targetFile);
+                renderedNavigationPages.add(targetShellFile);
                 const contextOntologyIri = inferOntologyIriFromMemberIri(memberIri);
                 const sourceDocumentUri = resolution.template.sourceUri?.trim() || pathToFileURL(path.join(workspaceRoot, 'index.md')).toString();
                 const invocation = {
@@ -2940,8 +2992,11 @@ class InMemoryJsonRpcLspClient {
                     },
                     args: {},
                 };
-                const rendered = renderTemplate(resolution.template, invocation);
-                if (rendered.missingRequired.length > 0) {
+                let rendered;
+                try {
+                    rendered = renderTemplate(resolution.template, invocation);
+                }
+                catch {
                     continue;
                 }
                 const syntheticSourcePath = resolution.template.sourceUri?.startsWith('file:')
@@ -2961,7 +3016,7 @@ class InMemoryJsonRpcLspClient {
                         inputRoot: inputDir,
                         inputFile: syntheticSourcePath,
                         outputRoot: outputDir,
-                        outputFile: targetFile,
+                        outputFile: targetShellFile,
                     });
                     for (const asset of rewriteResult.workspaceAssets) {
                         workspaceAssetFiles.add(asset);
@@ -2983,18 +3038,20 @@ class InMemoryJsonRpcLspClient {
                         inputRoot: inputDir,
                         sourceFile: syntheticSourcePath,
                         outputRoot: outputDir,
-                        outputFile: targetFile,
+                        outputFile: targetShellFile,
                     }, workspaceAssetFiles));
-                    const blockArtifacts = await writeBlockArtifacts(targetFile, rewrittenBlockResults);
+                    const blockArtifacts = await writeBlockArtifacts(targetShellFile, rewrittenBlockResults);
                     blockArtifactFiles += blockArtifacts.count;
                     const scriptSparqlCache = await buildScriptSparqlCache(prepared.codeBlocks, (sparql) => reasoningService.getSparqlService().query(modelUri, sparql));
+                    const scriptIncludeCache = await buildScriptIncludeCache(prepared.codeBlocks, workspaceRoot);
                     renderJobs.push({
-                        htmlPath: targetFile,
+                        shellPath: targetShellFile,
                         renderedHtml: rewriteResult.html,
                         blockManifest: blockArtifacts.manifest,
                         blockResults: rewrittenBlockResults,
-                        wikiLinkHrefByKey: buildWikiLinkHrefMapForPage(wikiPageIndex, targetFile),
+                        wikiLinkHrefByKey: buildWikiLinkHrefMapForPage(wikiPageIndex, targetShellFile),
                         scriptSparqlCache,
+                        scriptIncludeCache,
                     });
                     filesRendered += 1;
                 });
@@ -3003,12 +3060,12 @@ class InMemoryJsonRpcLspClient {
         for (const task of navTasks) {
             await task();
         }
+        const shellContentByRelPath = new Map();
         for (const job of renderJobs) {
-            const runtimeScriptRelative = toRelativeWebPath(path.dirname(job.htmlPath), staticAssets.runtimeScriptFile);
-            const stylesheetRelative = toRelativeWebPath(path.dirname(job.htmlPath), staticAssets.stylesheetFile);
-            const html = wrapHtml(job.renderedHtml, runtimeScriptRelative, stylesheetRelative, job.blockManifest, job.blockResults, job.wikiLinkHrefByKey, buildIriAliasMapForPage(aliasesByIri, job.htmlPath), job.scriptSparqlCache);
-            await fs.mkdir(path.dirname(job.htmlPath), { recursive: true });
-            await fs.writeFile(job.htmlPath, html, 'utf-8');
+            const runtimeScriptRelative = toRelativeWebPath(path.dirname(job.shellPath), staticAssets.runtimeScriptFile);
+            const stylesheetRelative = toRelativeWebPath(path.dirname(job.shellPath), staticAssets.stylesheetFile);
+            const html = wrapHtml(job.renderedHtml, runtimeScriptRelative, stylesheetRelative, job.blockManifest, job.blockResults, job.wikiLinkHrefByKey, buildIriAliasMapForPage(aliasesByIri, job.shellPath), job.scriptSparqlCache, job.scriptIncludeCache);
+            shellContentByRelPath.set(path.relative(outputDir, job.shellPath).replace(/\\/g, '/'), html);
         }
         for (const file of workspaceAssetFiles) {
             const workspaceRelative = path.relative(workspaceRoot, file);
@@ -3034,6 +3091,33 @@ class InMemoryJsonRpcLspClient {
                 }
             }
         }
+        const workspaceSettings = await readWorkspaceSettings(workspaceRoot);
+        const projectTitle = workspaceSettings.project?.title?.trim() || undefined;
+        const indexEntry = mdHtmlPaths.find(p => path.relative(outputDir, p).replace(/\\/g, '/').toLowerCase() === 'index.html');
+        const homePath = indexEntry ? path.relative(outputDir, indexEntry).replace(/\\/g, '/') : undefined;
+        const shellPaths = renderJobs.map(j => j.shellPath);
+        const shellPathSet = new Set(shellPaths.map(p => path.relative(outputDir, p).replace(/\\/g, '/')));
+        const contentPathByShellRelPath = new Map();
+        for (const [shellRelPath, contentHtml] of shellContentByRelPath) {
+            const shellFile = path.join(outputDir, shellRelPath);
+            const contentRelPath = contentRelPathForShell(shellRelPath);
+            const contentFile = path.join(outputDir, contentRelPath);
+            const shellHrefFromContent = toRelativeWebPath(path.dirname(contentFile), shellFile);
+            const html = contentHtml.replace(/__OML_SHELL_BASE_HREF__/g, escapeAttribute(shellHrefFromContent));
+            await fs.mkdir(path.dirname(contentFile), { recursive: true });
+            await fs.writeFile(contentFile, html, 'utf-8');
+            contentPathByShellRelPath.set(shellRelPath, contentRelPath);
+        }
+        for (const shellRelPath of shellPathSet) {
+            const shellHtml = generateShellIndex(outputDir, mdHtmlPaths, projectTitle, homePath, shellPaths, shellRelPath, contentPathByShellRelPath.get(shellRelPath));
+            const shellFile = path.join(outputDir, shellRelPath);
+            await fs.mkdir(path.dirname(shellFile), { recursive: true });
+            await fs.writeFile(shellFile, shellHtml, 'utf-8');
+        }
+        if (!shellPathSet.has('index.html')) {
+            const indexHtml = generateShellIndex(outputDir, mdHtmlPaths, projectTitle, undefined, shellPaths);
+            await fs.writeFile(path.join(outputDir, 'index.html'), indexHtml, 'utf-8');
+        }
         return { success: true, filesRendered, outputDir, blockArtifactFiles };
     }
     async ontologiesWorkspace() {
@@ -3204,7 +3288,16 @@ class InMemoryJsonRpcLspClient {
             .map((uri) => URI.parse(uri));
         await Promise.all(changedUris.map((uri) => documents.getOrCreateDocument(uri)));
         const builder = this.runtime.shared.workspace.DocumentBuilder;
-        await builder.update(changedUris, deletedUris);
+        const reasoningService = this.runtime.Oml.reasoning.ReasoningService;
+        const runUpdate = async () => {
+            await builder.update(changedUris, deletedUris);
+        };
+        if (typeof reasoningService?.suppressSemanticChangeNotifications === 'function') {
+            await reasoningService.suppressSemanticChangeNotifications(runUpdate);
+        }
+        else {
+            await runUpdate();
+        }
         await this.waitForValidatedWithTrace();
     }
     async bootstrapWorkspaceOmlDocuments() {