@platformos/platformos-common 0.0.15 → 0.0.16

package/src/route-table/RouteTable.ts

@@ -16,7 +16,9 @@ function extractFrontmatter(source: string): PageFrontmatter | null {
   const trimmed = source.trimStart();
   if (!trimmed.startsWith('---')) return null;
 
-  const end = trimmed.indexOf('---', 3);
+  // Search for the closing delimiter as `\n---` so we don't accidentally match
+  // a `---` sequence that appears inside a YAML value (e.g. `slug: my---slug`).
+  const end = trimmed.indexOf('\n---', 3);
   if (end === -1) return null;
 
   const yamlBlock = trimmed.slice(3, end).trim();
@@ -48,7 +50,7 @@ function extractFrontmatter(source: string): PageFrontmatter | null {
  *   file:///project/app/views/pages/about.html.liquid -> about.html.liquid
  *   file:///project/modules/admin/public/views/pages/dashboard.html.liquid -> dashboard.html.liquid
  */
-function extractRelativePagePath(uri: string): string | null {
+export function extractRelativePagePath(uri: string): string | null {
   const patterns = [
     // App-level pages: app/views/pages/ or marketplace_builder/pages/
     /\/(app|marketplace_builder)\/(views\/pages|pages)\//,
@@ -187,6 +189,21 @@ export class RouteTable {
     return this._built;
   }
 
+  /**
+   * Populate the route table from an in-memory collection of URI → content
+   * pairs, bypassing the filesystem entirely. Useful for warming the table
+   * from a DocumentManager without a full disk scan on startup.
+   *
+   * Only page URIs are registered; non-page URIs are silently skipped.
+   */
+  buildFromEntries(entries: Iterable<[uri: string, content: string]>): void {
+    this.routes.clear();
+    for (const [uri, content] of entries) {
+      this.addPageFromContent(uri, content);
+    }
+    this._built = true;
+  }
+
   async build(rootUri: URI): Promise<void> {
     this.routes.clear();
 

package/src/route-table/index.ts

@@ -1,4 +1,4 @@
-export { RouteTable } from './RouteTable';
+export { RouteTable, extractRelativePagePath } from './RouteTable';
 export { slugFromFilePath, formatFromFilePath, KNOWN_FORMATS } from './slugFromFilePath';
 export { parseSlug, calculatePrecedence } from './parseSlug';
 export type { RouteEntry, RouteSegment } from './types';

package/src/translation-provider/TranslationProvider.ts

@@ -1,14 +1,34 @@
 import { AbstractFileSystem, FileType } from '../AbstractFileSystem';
+import { parseModulePrefix } from '../path-utils';
 import { URI, Utils } from 'vscode-uri';
 import yaml from 'js-yaml';
 
-type ModuleKeyInfo =
-  | { isModule: false; key: string }
-  | { isModule: true; moduleName: string; key: string };
-
 export class TranslationProvider {
   constructor(private readonly fs: AbstractFileSystem) {}
 
+  /** Cache for filesystem-only translation loads (bypassed when contentOverride is set). */
+  private translationsCache = new Map<string, Record<string, any>>();
+
+  /**
+   * Invalidate cached translations. Call after any translation file is written
+   * to disk so subsequent calls re-read from the filesystem.
+   *
+   * Omitting `uri` clears the entire cache.
+   * Passing a `uri` removes only the entries whose base directory contains that file.
+   */
+  clearTranslationsCache(uri?: string): void {
+    if (!uri) {
+      this.translationsCache.clear();
+      return;
+    }
+    for (const key of this.translationsCache.keys()) {
+      const baseUri = key.slice(0, key.lastIndexOf(':'));
+      if (uri.startsWith(baseUri)) {
+        this.translationsCache.delete(key);
+      }
+    }
+  }
+
   private async isFile(path: string): Promise<boolean> {
     try {
       return (await this.fs.stat(path)).type === FileType.File;
@@ -42,16 +62,6 @@ export class TranslationProvider {
     return true;
   }
 
-  private parseModuleKey(translationKey: string): ModuleKeyInfo {
-    if (!translationKey.startsWith('modules/')) {
-      return { isModule: false, key: translationKey };
-    }
-
-    const [, moduleName, key] = translationKey.split('/', 3);
-
-    return key ? { isModule: true, moduleName, key } : { isModule: false, key: translationKey };
-  }
-
   static getSearchPaths(moduleName?: string): string[] {
     if (!moduleName) {
       return ['app/translations'];
@@ -70,7 +80,7 @@ export class TranslationProvider {
     translationKey: string,
     defaultLocale: string,
   ): Promise<[string | undefined, string | undefined]> {
-    const parsed = this.parseModuleKey(translationKey);
+    const parsed = parseModulePrefix(translationKey);
 
     if (!parsed.key) {
       return [undefined, undefined];
@@ -129,6 +139,14 @@ export class TranslationProvider {
     locale: string,
     contentOverride?: (uri: string) => string | undefined,
   ): Promise<Record<string, any>> {
+    const cacheKey = `${translationBaseUri.toString()}:${locale}`;
+
+    // Return cached result when the caller has no editor overrides (e.g. linter/CI).
+    // Skip cache when contentOverride is set — unsaved buffer content may differ from disk.
+    if (!contentOverride && this.translationsCache.has(cacheKey)) {
+      return this.translationsCache.get(cacheKey)!;
+    }
+
     const merged: Record<string, any> = {};
 
     const read = async (uri: string): Promise<string | undefined> => {
@@ -158,6 +176,10 @@ export class TranslationProvider {
       }
     }
 
+    if (!contentOverride) {
+      this.translationsCache.set(cacheKey, merged);
+    }
+
     return merged;
   }