Support export default class

Author: guyca

packages/vscode-language-server-obsidian/server/src/dto/identifier.ts

@@ -1,4 +1,4 @@
-import { Identifier as IdentifierNode, Node } from "ts-morph";
+import { Identifier as IdentifierNode, ImportClause, ImportDeclaration, ImportSpecifier, Node } from "ts-morph";
 import { Import } from "./import";
 
 export class Identifier {
@@ -10,8 +10,16 @@ export class Identifier {
 
   public get import() {
     const declarations = this.node.getSymbol()?.getDeclarations();
-    const declaration = declarations?.find(Node.isImportSpecifier);
-    const importDeclaration = declaration?.getImportDeclaration();
+    const declaration = declarations?.find(d => Node.isImportSpecifier(d) || Node.isImportClause(d));
+    const importDeclaration = this.getImportDeclaration(declaration);
     return importDeclaration && new Import(importDeclaration);
   }
+
+  private getImportDeclaration(declaration: ImportSpecifier | ImportClause | undefined) {
+    if (Node.isImportSpecifier(declaration)) {
+      return declaration.getImportDeclaration();
+    } else if (Node.isImportClause(declaration)) {
+      return declaration.getParent() as ImportDeclaration;
+    }
+  }
 }

packages/vscode-language-server-obsidian/server/tests/integration/goToDefinition/goToDefinition.test.ts

@@ -2,7 +2,6 @@ import { TextDocuments } from "vscode-languageserver/node";
 import { DefinitionCommand } from "../../../src/commands/definition/definitionCommand";
 import { StrategyFactory } from "../../../src/commands/definition/strategies/goToDefinitionStrategyFactory";
 import { ProjectAdapter } from "../../../src/services/ast/projectAdapter";
-import { Logger } from "../../../src/services/logger";
 import { TextDocument } from "vscode-languageserver-textdocument";
 import { mockDeep, mock } from "jest-mock-extended";
 import { when } from "jest-when";
@@ -14,13 +13,15 @@ import dependencyInSameGraph from "./dependencyInSameGraph";
 import dependencyInSubgraph from "./dependencyInSubgraph";
 import injectedClass from "./injectedClass";
 import injectedHookDifferentInjectedTypeName from "./injectedHookDifferentInjectedTypeName";
+import injectedExportDefaultClass from "./injectedExportDefaultClass";
 
 const testCases: TestCase[] = [
   injectedHook,
   dependencyInSameGraph,
   dependencyInSubgraph,
   injectedClass,
-  injectedHookDifferentInjectedTypeName
+  injectedHookDifferentInjectedTypeName,
+  injectedExportDefaultClass
 ];
 
 describe('GoToDefinition', () => {

packages/vscode-language-server-obsidian/server/tests/integration/goToDefinition/injectedExportDefaultClass/index.ts

@@ -0,0 +1,31 @@
+import { TestCase } from "../..";
+import { entryGraphContent } from "./sourceCodes/entryGraph";
+import { entryPoint } from "./sourceCodes/entryPoint";
+import { gameGraph } from "./sourceCodes/gameGraph";
+import { gameModel } from "./sourceCodes/gameModel";
+
+export default {
+  entryPoint,
+  additionalSourceCodes: [
+    gameGraph,
+    entryGraphContent,
+    gameModel
+  ],
+  position: {
+    line: 10,
+    character: 33
+  },
+  result: {
+    uri: '/core/model/GameModel.ts',
+    range: {
+      start: {
+        line: 7,
+        character: 0
+      },
+      end: {
+        line: 34,
+        character: 1
+      }
+    }
+  }
+} satisfies TestCase;

packages/vscode-language-server-obsidian/server/tests/integration/goToDefinition/injectedExportDefaultClass/sourceCodes/entryGraph.ts

@@ -0,0 +1,29 @@
+import { SourceCode } from "../../..";
+
+export const entryGraphContent: SourceCode = {
+  path: './di/EntryGraph',
+  content: `import { Graph, ObjectGraph, Provides } from 'react-obsidian';
+import { useEntryViewModel } from '../model/entryViewModel';
+import { GameGraph } from '../../../core/di/GameGraph';
+import { type Props } from '../Entry';
+import type GameModel from '../../../core/model/GameModel';
+
+@Graph({ subgraphs: [GameGraph] })
+export class EntryGraph extends ObjectGraph {
+  private index: number;
+
+  constructor(props: Props) {
+    super(props);
+    this.index = props.index;
+  }
+
+  @Provides()
+  useViewModel(model: GameModel) {
+    return () => useEntryViewModel(this.index, model);
+  }
+
+  @Provides()
+  foo() {
+    return 'foo';
+  }
+}`};

packages/vscode-language-server-obsidian/server/tests/integration/goToDefinition/injectedExportDefaultClass/sourceCodes/entryPoint.ts

@@ -0,0 +1,28 @@
+import { SourceCode } from "../../..";
+
+export const entryPoint: SourceCode = {
+  path: 'entry.tsx',
+  content: `import { type DependenciesOf, injectComponent } from 'react-obsidian';
+import { EntryGraph } from './di/EntryGraph';
+import type { GameGraph } from '../../core/di/GameGraph';
+
+export type Props = {
+  index: number
+};
+
+type Injected = DependenciesOf<[EntryGraph, GameGraph], 'useViewModel' | 'foo' | 'model'>;
+
+const Entry_ = ({ useViewModel, model }: Props & Injected) => {
+  const { text, onClick } = useViewModel();
+
+  return (
+    <li>
+      <button onClick={onClick}>{text}</button>
+    </li>
+  );
+};
+
+export const Entry = injectComponent<Props, Injected>(Entry_, EntryGraph);
+export const createEntry = (_: unknown, index: number) => <Entry index={index} />;
+`
+}

packages/vscode-language-server-obsidian/server/tests/integration/goToDefinition/injectedExportDefaultClass/sourceCodes/gameGraph.ts

@@ -0,0 +1,15 @@
+import { SourceCode } from "../../..";
+
+export const gameGraph: SourceCode = {
+  path: '../../../core/di/GameGraph.ts',
+  content: `import { Graph, ObjectGraph, Provides, Singleton } from 'react-obsidian';
+import GameModel from '../model/GameModel';
+import { CalculateWinnerUseCase } from '../usecases/CalculateWinnerUseCase';
+
+@Singleton() @Graph()
+export class GameGraph extends ObjectGraph {
+  @Provides()
+  model(): GameModel {
+    return new GameModel(new CalculateWinnerUseCase());
+  }
+}`};

packages/vscode-language-server-obsidian/server/tests/integration/goToDefinition/injectedExportDefaultClass/sourceCodes/gameModel.ts

@@ -0,0 +1,40 @@
+import { SourceCode } from "../../..";
+
+export const gameModel: SourceCode = {
+  path: '../../../core/model/GameModel.ts',
+  content: `import { MediatorObservable, Model, Observable } from 'react-obsidian';
+import { CurrentPlayer } from '../entities/CurrentPlayer';
+import { Squares } from '../entities/Squares';
+import { type CalculateWinnerUseCase } from '../usecases/CalculateWinnerUseCase';
+import { History } from '../entities/History';
+import { persist } from '../../persistency/persist.legacy';
+
+export default class GameModel extends Model {
+  @persist('CurrentPlayer') private readonly currentPlayer = new CurrentPlayer('X');
+  @persist('Squares') private readonly squares = new Squares();
+  @persist('History') private readonly history = new History(this.squares.value);
+  @persist('Status') public readonly status = new MediatorObservable<string>();
+  @persist('IsReady') public readonly isReady = new Observable<boolean>(false);
+
+  constructor(calculateWinnerUseCase: CalculateWinnerUseCase) {
+    super();
+    this.status.mapSource(this.currentPlayer, (player) => {
+      const winner = calculateWinnerUseCase.calculate(this.squares.value);
+      return winner ? \`Winner: \${winner}\` : \`Next player: \${player}\`;
+    });
+  }
+
+  public onSquareClick(index: number) {
+    if (this.squares.value[index]) return;
+    this.squares.mark(index, this.currentPlayer.value);
+    this.currentPlayer.nextPlayer();
+    this.history.add(this.squares.value, this.currentPlayer.value);
+  }
+
+  public onHistoryEntryClick(index: number) {
+    this.history.goTo(index);
+    this.squares.value = this.history.value[index].squares;
+    this.currentPlayer.value = this.history.value[index].currentPlayer;
+  }
+}
+`};