test: move tests out of packages

Author: ark120202

.editorconfig

@@ -8,5 +8,5 @@ charset = utf-8
 trim_trailing_whitespace = true
 insert_final_newline = true
 
-[packages/*/{types,normalized}/**/*]
+[packages/*/types/**/*]
 indent_size = 4

.eslintrc.json

@@ -1,20 +1,25 @@
 {
   "extends": "@ark120202/eslint-config/node",
   "parserOptions": {
-    "project": ["build/tsconfig.json", "packages/*/{,types,normalized}/tsconfig.json"]
+    "project": [
+      "build/tsconfig.json",
+      "test/*/tsconfig.json",
+      "packages/*/tsconfig.json",
+      "packages/*/types/tsconfig.json"
+    ]
   },
   "overrides": [
     {
-      "files": "packages/*/{types,normalized}/**/*",
+      "files": ["test/**/*", "packages/*/types/**/*"],
       "rules": {
         "no-plusplus": "off",
         "no-var": "off",
         "vars-on-top": "off",
+        "unicorn/prevent-abbreviations": "off",
         "@typescript-eslint/camelcase": "off",
         "@typescript-eslint/class-name-casing": "off",
         "@typescript-eslint/no-empty-interface": "off",
-        "@typescript-eslint/no-unused-expressions": "off",
-        "unicorn/prevent-abbreviations": "off"
+        "@typescript-eslint/no-unused-expressions": "off"
       }
     }
   ]

package.json

@@ -14,7 +14,7 @@
     "lint:eslint": "eslint . --ext .js,.ts",
     "lint:prettier": "prettier --check **/*.{ts,md,yml,json}",
     "prepublishOnly": "yarn build",
-    "test": "lerna run --parallel test"
+    "test": "tsc -b test"
   },
   "nodemonConfig": {
     "delay": 500,
@@ -37,9 +37,7 @@
     "trailingComma": "all",
     "overrides": [
       {
-        "files": [
-          "packages/*/{types,normalized}/**/*"
-        ],
+        "files": "packages/*/types/**/*",
         "options": {
           "printWidth": 120
         }

packages/dota-lua-types/normalized.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="./types/common" />
+/// <reference types="./types/enums-normalized.generated" />

packages/dota-lua-types/normalized/index.d.ts

@@ -10,7 +10,8 @@
   "files": [
     "enum-mappings.json",
     "transformer/index.{js,d.ts}",
-    "{types,normalized}/**/*.d.ts"
+    "types/**/*.d.ts",
+    "normalized.d.ts"
   ],
   "types": "types/index.d.ts",
   "scripts": {

packages/dota-lua-types/normalized/tsconfig.json

@@ -1,6 +1,6 @@
 {
     "extends": "@ark120202/typescript-config/base.json",
-    "include": ["index.d.ts", "test/**/*"],
+    "files": ["index.d.ts"],
     "compilerOptions": {
         "noEmit": true,
         "lib": ["esnext"]

packages/dota-lua-types/package.json

@@ -1,6 +1,6 @@
 {
     "extends": "@ark120202/typescript-config/base.json",
-    "include": ["**/*"],
+    "files": ["index.d.ts"],
     "compilerOptions": {
         "noEmit": true,
         "lib": ["es2017"]

packages/dota-lua-types/types/test/common.ts

@@ -2,5 +2,5 @@ const hero = HeroList.GetHero(0)!;
 hero.ModifyGold(100, true, ModifyGoldReason.UNSPECIFIED);
 
 for (let rune: RuneType = 0; rune < DOTA_RUNE_COUNT; rune++) {
-    GameRules.GetGameModeEntity().SetRuneEnabled(rune, false);
+  GameRules.GetGameModeEntity().SetRuneEnabled(rune, false);
 }

packages/dota-lua-types/types/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "extends": "@ark120202/typescript-config/base.json",
+  "include": ["**/*", "../utils.d.ts"],
+  "compilerOptions": {
+    "types": ["dota-lua-types/normalized"],
+    "lib": ["esnext"],
+    "noEmit": true
+  }
+}

packages/panorama-types/types/tsconfig.json

@@ -1,12 +1,12 @@
 const hero = HeroList.GetHero(0);
 assertType<CDOTA_BaseNPC_Hero | undefined>(hero);
 if (IsValidEntity(hero)) {
-    assertType<CDOTA_BaseNPC_Hero>(hero);
+  assertType<CDOTA_BaseNPC_Hero>(hero);
 }
 
 const mayBeEntity = undefined as any;
 if (IsValidEntity(mayBeEntity)) {
-    assertType<CBaseEntity>(mayBeEntity);
+  assertType<CBaseEntity>(mayBeEntity);
 }
 
 export {};

packages/dota-lua-types/normalized/test/enums.ts renamed to test/lua-normalized/enums.ts

@@ -2,7 +2,7 @@ const hero = HeroList.GetHero(0)!;
 hero.ModifyGold(100, true, EDOTA_ModifyGold_Reason.DOTA_ModifyGold_Unspecified);
 
 for (let rune: DOTA_RUNES = 0; rune < DOTA_RUNES.DOTA_RUNE_COUNT; rune++) {
-    GameRules.GetGameModeEntity().SetRuneEnabled(rune, false);
+  GameRules.GetGameModeEntity().SetRuneEnabled(rune, false);
 }
 
 export {};

test/lua-normalized/tsconfig.json

@@ -1,50 +1,50 @@
 ListenToGameEvent(
-    'npc_spawned',
-    event => {
-        assertType<EntityIndex>(event.entindex);
-    },
-    undefined,
+  'npc_spawned',
+  event => {
+    assertType<EntityIndex>(event.entindex);
+  },
+  undefined,
 );
 
 class GameMode {
-    public npcSpawned(this: this, event: NpcSpawnedEvent) {
-        assertType<GameMode>(this);
-        assertType<EntityIndex>(event.entindex);
-    }
+  public npcSpawned(this: this, event: NpcSpawnedEvent) {
+    assertType<GameMode>(this);
+    assertType<EntityIndex>(event.entindex);
+  }
 }
 
 const gameMode = new GameMode();
 ListenToGameEvent('npc_spawned', gameMode.npcSpawned, gameMode);
 
 declare global {
-    interface GameEventDeclarations {
-        game_event: { foo: string };
-    }
+  interface GameEventDeclarations {
+    game_event: { foo: string };
+  }
 }
 
 ListenToGameEvent('game_event', event => assertType<string>(event.foo), undefined);
 FireGameEvent('game_event', { foo: 'bar' });
 FireGameEventLocal('game_event', { foo: 'bar' });
 
 declare global {
-    interface CustomGameEventDeclarations {
-        declared_event: { foo: string };
-    }
+  interface CustomGameEventDeclarations {
+    declared_event: { foo: string };
+  }
 }
 
 CustomGameEventManager.RegisterListener('declared_event', (_, e) => assertType<string>(e.foo));
 CustomGameEventManager.RegisterListener<{ foo: string }>('inline_event', (_, event) => {
-    assertType<string>(event.foo);
+  assertType<string>(event.foo);
 });
 CustomGameEventManager.RegisterListener('untyped_event', (_, event) => {
-    assertType<object>(event);
-    assertType<PlayerID>(event.PlayerID);
-    // @ts-ignore TODO: Expect error
-    event.foo;
+  assertType<object>(event);
+  assertType<PlayerID>(event.PlayerID);
+  // @ts-ignore TODO: Expect error
+  event.foo;
 });
 
 CustomGameEventManager.RegisterListener('', (_, event) => {
-    assertType<PlayerID>(event.PlayerID);
+  assertType<PlayerID>(event.PlayerID);
 });
 
 CustomGameEventManager.Send_ServerToAllClients('declared_event', { foo: 'bar' });
@@ -53,12 +53,12 @@ CustomGameEventManager.Send_ServerToAllClients<{ foo: 'bar' }>('inline_event', {
 CustomGameEventManager.Send_ServerToAllClients('untyped_event', {});
 
 declare global {
-    interface CustomNetTableDeclarations {
-        custom_net_table: {
-            foo: string;
-            bar: number;
-        };
-    }
+  interface CustomNetTableDeclarations {
+    custom_net_table: {
+      foo: string;
+      bar: number;
+    };
+  }
 }
 
 CustomNetTables.SetTableValue('custom_net_table', 'foo', 'value');

packages/dota-lua-types/types/test/classes.ts renamed to test/lua/classes.ts

@@ -0,0 +1,9 @@
+{
+  "extends": "@ark120202/typescript-config/base.json",
+  "include": ["**/*", "../utils.d.ts"],
+  "compilerOptions": {
+    "types": ["dota-lua-types"],
+    "lib": ["esnext"],
+    "noEmit": true
+  }
+}

packages/dota-lua-types/types/test/entities.ts renamed to test/lua/entities.ts

@@ -1,36 +1,34 @@
-const assertType = <T>(value: T) => value;
-
 GameEvents.Subscribe('npc_spawned', event => {
-    assertType<EntityIndex>(event.entindex);
+  assertType<EntityIndex>(event.entindex);
 });
 
 declare global {
-    interface GameEventDeclarations {
-        game_event: { foo: string };
-    }
+  interface GameEventDeclarations {
+    game_event: { foo: string };
+  }
 }
 
 GameEvents.Subscribe('game_event', event => assertType<string>(event.foo));
 GameEvents.SendEventClientSide('game_event', { foo: 'bar' });
 
 declare global {
-    interface CustomGameEventDeclarations {
-        declared_event: { foo: string };
-    }
+  interface CustomGameEventDeclarations {
+    declared_event: { foo: string };
+  }
 }
 
 GameEvents.Subscribe('declared_event', event => assertType<string>(event.foo));
 GameEvents.Subscribe<{ foo: string }>('inline_event', event => assertType<string>(event.foo));
 GameEvents.Subscribe('untyped_event', event => {
-    assertType<object>(event);
-    // @ts-ignore TODO: Expect error
-    event.foo;
+  assertType<object>(event);
+  // @ts-ignore TODO: Expect error
+  event.foo;
 });
 
 GameEvents.Subscribe<{ array: string[]; boolean: boolean; symbol: symbol }>('type_test', event => {
-    assertType<Record<number, string>>(event.array);
-    assertType<0 | 1>(event.boolean);
-    assertType<{}>(event.symbol);
+  assertType<Record<number, string>>(event.array);
+  assertType<0 | 1>(event.boolean);
+  assertType<never>(event.symbol);
 });
 
 GameEvents.SendCustomGameEventToServer('declared_event', { foo: 'bar' });
@@ -39,28 +37,28 @@ GameEvents.SendCustomGameEventToServer<{ foo: 'bar' }>('inline_event', { foo: 'b
 GameEvents.SendCustomGameEventToServer('untyped_event', {});
 
 declare global {
-    interface CustomNetTableDeclarations {
-        custom_net_table: {
-            foo: string;
-            bar: boolean;
-        };
-    }
+  interface CustomNetTableDeclarations {
+    custom_net_table: {
+      foo: string;
+      bar: boolean;
+    };
+  }
 }
 
 assertType<string>(CustomNetTables.GetTableValue('custom_net_table', 'foo'));
 assertType<0 | 1>(CustomNetTables.GetTableValue('custom_net_table', 'bar'));
 
 for (const pair of CustomNetTables.GetAllTableValues('custom_net_table')) {
-    if (pair.key === 'foo') {
-        assertType<string>(pair.value);
-    } else {
-        assertType<0 | 1>(pair.value);
-    }
+  if (pair.key === 'foo') {
+    assertType<string>(pair.value);
+  } else {
+    assertType<0 | 1>(pair.value);
+  }
 }
 
 CustomNetTables.SubscribeNetTableListener('custom_net_table', (_tableName, key, value) => {
-    assertType<'foo' | 'bar'>(key);
-    assertType<string | 0 | 1>(value);
+  assertType<'foo' | 'bar'>(key);
+  assertType<string | 0 | 1>(value);
 });
 
 export {};

packages/dota-lua-types/types/test/enums.ts renamed to test/lua/enums.ts

@@ -0,0 +1,9 @@
+{
+  "extends": "@ark120202/typescript-config/base.json",
+  "include": ["**/*", "../utils.d.ts"],
+  "compilerOptions": {
+    "types": ["panorama-types"],
+    "lib": ["es2017"],
+    "noEmit": true
+  }
+}

packages/dota-lua-types/types/test/events.ts renamed to test/lua/events.ts

@@ -0,0 +1,4 @@
+{
+  "files": [],
+  "references": [{ "path": "lua" }, { "path": "lua-normalized" }, { "path": "panorama" }]
+}

test/lua/tsconfig.json

@@ -0,0 +1 @@
+declare function assertType<T>(value: T): T;