@platformos/platformos-language-server-common 0.0.7 → 0.0.8

package/src/server/{ThemeGraphManager.ts → AppGraphManager.ts}

@@ -1,13 +1,7 @@
-import {
-  path,
-  recursiveReadDirectory,
-  SectionSchema,
-  SourceCodeType,
-  ThemeBlockSchema,
-} from '@platformos/platformos-check-common';
+import { path, SourceCodeType } from '@platformos/platformos-check-common';
 import { AbstractFileSystem } from '@platformos/platformos-common';
 import {
-  buildThemeGraph,
+  buildAppGraph,
   getWebComponentMap,
   IDependencies as GraphDependencies,
   Location,
@@ -22,40 +16,36 @@ import {
   AugmentedLocation,
   AugmentedLocationWithExistence,
   AugmentedReference,
-  ThemeGraphDidUpdateNotification,
+  AppGraphDidUpdateNotification,
 } from '../types';
 import { debounce } from '../utils';
-import { FindThemeRootURI } from '../internal-types';
+import { FindAppRootURI } from '../internal-types';
 
-export class ThemeGraphManager {
-  graphs: Map<string, ReturnType<typeof buildThemeGraph>> = new Map();
+export class AppGraphManager {
+  graphs: Map<string, ReturnType<typeof buildAppGraph>> = new Map();
 
   constructor(
     private connection: Connection,
     private documentManager: DocumentManager,
     private fs: AbstractFileSystem,
-    private findThemeRootURI: FindThemeRootURI,
+    private findAppRootURI: FindAppRootURI,
   ) {}
 
-  async getThemeGraphForURI(uri: string) {
-    const rootUri = await this.findThemeRootURI(uri);
+  async getAppGraphForURI(uri: string) {
+    const rootUri = await this.findAppRootURI(uri);
     if (!rootUri) {
       return undefined;
     }
 
     if (!this.graphs.has(rootUri)) {
-      this.graphs.set(rootUri, this.buildThemeGraph(rootUri));
+      this.graphs.set(rootUri, this.buildAppGraph(rootUri));
     }
 
     return this.graphs.get(rootUri);
   }
 
-  async getReferences(
-    uri: string,
-    offset?: number,
-    { includeIndirect = true, includePreset = true } = {},
-  ) {
-    const graph = await this.getThemeGraphForURI(uri);
+  async getReferences(uri: string, offset?: number, { includeIndirect = true } = {}) {
+    const graph = await this.getAppGraphForURI(uri);
     if (!graph) return [];
 
     const module = graph.modules[uri];
@@ -64,7 +54,6 @@ export class ThemeGraphManager {
     const includedTypes: (AugmentedReference['type'] | undefined)[] = [
       'direct',
       includeIndirect ? 'indirect' : undefined,
-      includePreset ? 'preset' : undefined,
     ];
 
     const refs = module.references.filter((dep) => includedTypes.includes(dep.type));
@@ -84,31 +73,16 @@ export class ThemeGraphManager {
     );
   }
 
-  async getDependencies(
-    uri: string,
-    offset?: number,
-    { includeIndirect = true, includePreset = true } = {},
-  ) {
-    const graph = await this.getThemeGraphForURI(uri);
+  async getDependencies(uri: string, offset?: number, { includeIndirect = true } = {}) {
+    const graph = await this.getAppGraphForURI(uri);
     if (!graph) return [];
 
-    let module = graph.modules[uri];
-    if (!module) {
-      // If the module is not found, we might be dealing with dead code.
-      // dead code doesn't show up in the graph, but it might still have dependencies.
-      // So we're building a smaller graph with that file as entry point to figure
-      // out what it depends on.
-      const deadCodeGraph = await this.buildThemeGraph(graph.rootUri, [uri]);
-      module = deadCodeGraph.modules[uri];
-    }
-
-    // If the module is still not found, we return an empty array.
+    const module = graph.modules[uri];
     if (!module) return [];
 
     const includedTypes: (AugmentedReference['type'] | undefined)[] = [
       'direct',
       includeIndirect ? 'indirect' : undefined,
-      includePreset ? 'preset' : undefined,
     ];
 
     const deps = module.dependencies.filter((dep) => includedTypes.includes(dep.type)) ?? [];
@@ -148,33 +122,6 @@ export class ThemeGraphManager {
     };
   }
 
-  async deadCode(rootUri: string): Promise<string[]> {
-    const graph = await this.getThemeGraphForURI(rootUri);
-    if (!graph) return [];
-
-    const files = await recursiveReadDirectory(
-      this.fs,
-      rootUri,
-      ([uri]) =>
-        ['assets', 'blocks', 'layout', 'sections', 'snippets', 'templates'].some((dir) =>
-          uri.startsWith(path.join(rootUri, dir)),
-        ) &&
-        (uri.endsWith('.liquid') ||
-          uri.endsWith('.json') ||
-          uri.endsWith('.js') ||
-          uri.endsWith('.css')),
-    );
-
-    const unusedFiles = new Set<string>();
-    for (const file of files) {
-      if (!graph.modules[file]) {
-        unusedFiles.add(file);
-      }
-    }
-
-    return Array.from(unusedFiles).sort();
-  }
-
   public operationQueue: string[] = [];
 
   async rename(oldUri: string, newUri: string) {
@@ -203,23 +150,23 @@ export class ThemeGraphManager {
     if (operations.length === 0) return;
 
     const anyUri = operations[0];
-    const rootUri = await this.findThemeRootURI(anyUri);
+    const rootUri = await this.findAppRootURI(anyUri);
     if (!rootUri) return;
 
     const graph = await this.graphs.get(rootUri);
     if (!graph) return;
 
     this.graphs.delete(rootUri);
-    await this.getThemeGraphForURI(rootUri);
-    this.connection.sendNotification(ThemeGraphDidUpdateNotification.type, { uri: rootUri });
+    await this.getAppGraphForURI(rootUri);
+    this.connection.sendNotification(AppGraphDidUpdateNotification.type, { uri: rootUri });
   }, 500);
 
-  private buildThemeGraph = async (rootUri: string, entryPoints?: string[]) => {
+  private buildAppGraph = async (rootUri: string, entryPoints?: string[]) => {
     const { documentManager } = this;
     await documentManager.preload(rootUri);
 
     const dependencies = await this.graphDependencies(rootUri);
-    return buildThemeGraph(rootUri, dependencies, entryPoints);
+    return buildAppGraph(rootUri, dependencies, entryPoints);
   };
 
   private getSourceCode = async (uri: string) => {
@@ -236,27 +183,11 @@ export class ThemeGraphManager {
   }
 
   private async graphDependencies(rootUri: string): Promise<GraphDependencies> {
-    const { documentManager, fs, getSourceCode } = this;
+    const { fs, getSourceCode } = this;
     const webComponentDefs = await this.getWebComponentMap(rootUri);
     return {
       fs: fs,
       getSourceCode: getSourceCode,
-      async getBlockSchema(name: string) {
-        const blockUri = path.join(rootUri, 'blocks', `${name}.liquid`);
-        const doc = documentManager.get(blockUri);
-        if (!doc || doc.type !== SourceCodeType.LiquidHtml) {
-          return;
-        }
-        return (await doc.getSchema()) as ThemeBlockSchema;
-      },
-      async getSectionSchema(name) {
-        const sectionUri = path.join(rootUri, 'sections', `${name}.liquid`);
-        const doc = documentManager.get(sectionUri);
-        if (!doc || doc.type !== SourceCodeType.LiquidHtml) {
-          return;
-        }
-        return (await doc.getSchema()) as SectionSchema;
-      },
       getWebComponentDefinitionReference(customElementName: string) {
         return webComponentDefs.get(customElementName);
       },

package/src/server/startServer.spec.ts

@@ -1,5 +1,5 @@
 import { allChecks, path } from '@platformos/platformos-check-common';
-import { MockFileSystem, MockTheme } from '@platformos/platformos-check-common/dist/test';
+import { MockFileSystem, MockApp } from '@platformos/platformos-check-common/dist/test';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import {
   DidChangeConfigurationNotification,
@@ -25,7 +25,7 @@ describe('Module: server', () => {
   let checkOnOpen: boolean | null = null;
   let connection: MockConnection;
   let dependencies: ReturnType<typeof getDependencies>;
-  let fileTree: MockTheme;
+  let fileTree: MockApp;
   let logger: any;
 
   beforeEach(() => {
@@ -375,25 +375,23 @@ describe('Module: server', () => {
     return flushAsync();
   }
 
-  function getDependencies(logger: any, fileTree: MockTheme): Dependencies {
-    const MissingTemplate = allChecks.filter((c) => c.meta.code === 'MissingTemplate');
+  function getDependencies(logger: any, fileTree: MockApp): Dependencies {
+    const MissingTemplate = allChecks.filter((c) => c.meta.code === 'MissingPartial');
 
     return {
       fs: new MockFileSystem(fileTree, mockRoot),
       log: logger,
       loadConfig: async () => ({
-        context: 'theme',
         settings: {},
         checks: MissingTemplate,
         rootUri: mockRoot,
       }),
-      themeDocset: {
+      platformosDocset: {
         graphQL: async () => null,
         filters: async () => [],
         objects: async () => [],
         liquidDrops: async () => [],
         tags: async () => [],
-        systemTranslations: async () => ({}),
       },
       jsonValidationSet: {
         schemas: async () => [],
@@ -403,11 +401,11 @@ describe('Module: server', () => {
 
   function missingTemplateDiagnostic() {
     return {
-      code: 'MissingTemplate',
+      code: 'MissingPartial',
       codeDescription: { href: expect.any(String) },
       message: "'foo' does not exist",
       severity: 1,
-      source: 'theme-check',
+      source: 'platformos-check',
       range: {
         start: {
           character: 10,