Change ts compilation flags

packages/asset-manager/src/asset-manager.library.ts

@@ -1,7 +1,7 @@
 import { BaseAssetManagerLibrary, type InitContext, NfFile, NfNotFound } from "@nanoforge/common";
 
 export class AssetManagerLibrary extends BaseAssetManagerLibrary {
-  private _assets: Map<string, string>;
+  private _assets?: Map<string, string>;
 
   get __name(): string {
     return "AssetManagerLibrary";
@@ -12,6 +12,7 @@ export class AssetManagerLibrary extends BaseAssetManagerLibrary {
   }
 
   public getAsset(path: string): NfFile {
+    if (!this._assets) this.throwNotInitializedError();
     const res = this._assets.get(this._parsePath(path));
     if (!res) throw new NfNotFound(path, "Asset");
     return new NfFile(res);

packages/common/src/context/contexts/library.context.ts

@@ -5,7 +5,7 @@ export enum LibraryStatusEnum {
 }
 
 export class LibraryContext {
-  protected _status: LibraryStatusEnum;
+  protected _status: LibraryStatusEnum = LibraryStatusEnum.UNLOADED;
 
   get status() {
     return this._status;

packages/common/src/exception/exceptions/not-initialized.exception.ts

@@ -0,0 +1,11 @@
+import { NfException } from "../abstracts/exception.abstract";
+
+export class NfNotInitializedException extends NfException {
+  get code(): number {
+    return 404;
+  }
+
+  constructor(item: string, type?: string) {
+    super(`${type ? `${type} - ` : ""}${item} not initialized.`);
+  }
+}

packages/common/src/exception/index.ts

@@ -1,2 +1,3 @@
-export { NfNotFound } from "./exceptions/not-found.exception";
 export { NfFetchException } from "./exceptions/fetch.exception";
+export { NfNotFound } from "./exceptions/not-found.exception";
+export { NfNotInitializedException } from "./exceptions/not-initialized.exception";

packages/common/src/library/libraries/library.ts

@@ -1,4 +1,5 @@
 import { type ClearContext, type InitContext } from "../../context";
+import { NfNotInitializedException } from "../../exception";
 import { RelationshipHandler } from "../relationship/relationship-handler";
 import { DEFAULT_LIBRARY_OPTIONS } from "./consts/library-options-default.const";
 import { type ILibrary, type ILibraryOptions } from "./library.type";
@@ -30,4 +31,8 @@ export abstract class Library implements ILibrary {
 
   // eslint-disable-next-line @typescript-eslint/no-unused-vars
   public async __clear(_context: ClearContext): Promise<void> {}
+
+  protected throwNotInitializedError(): never {
+    throw new NfNotInitializedException(this.__name, "Library");
+  }
 }

packages/common/src/library/manager/managers/base-library.manager.ts

@@ -4,9 +4,7 @@ import { LibraryHandle } from "../handle/library.handle";
 
 export class BaseLibraryManager {
   protected _libraries: LibraryHandle[] = [];
-  private _librariesIndex: {
-    [sym: symbol]: number;
-  };
+  private _librariesIndex: Record<symbol, number> = {};
 
   /**
    * @todo Add error management

packages/core/src/application/nanoforge-application.ts

@@ -4,6 +4,7 @@ import {
   type ILibrary,
   type INetworkLibrary,
   type IRunOptions,
+  NfNotInitializedException,
 } from "@nanoforge/common";
 
 import { EditableApplicationContext } from "../common/context/contexts/application.editable-context";
@@ -13,7 +14,7 @@ import type { IApplicationOptions } from "./application-options.type";
 
 export abstract class NanoforgeApplication {
   protected applicationConfig: ApplicationConfig;
-  private _core: Core;
+  private _core?: Core;
   private readonly _options: IApplicationOptions;
 
   constructor(options?: Partial<IApplicationOptions>) {
@@ -51,6 +52,7 @@ export abstract class NanoforgeApplication {
   }
 
   public run() {
-    return this._core.run();
+    if (!this._core) throw new NfNotInitializedException("Core");
+    return this._core?.run();
   }
 }

packages/core/src/common/library/manager/library.manager.ts

@@ -24,6 +24,10 @@ import {
 import { EditableLibraryContext } from "../../context/contexts/library.editable-context";
 import { Relationship } from "../relationship-functions";
 
+const hasMethod = (obj: any, method: string) => {
+  return typeof obj[method] === "function";
+};
+
 export class EditableLibraryManager extends LibraryManager {
   public set(sym: symbol, library: ILibrary) {
     this.setNewLibrary(sym, library, new EditableLibraryContext());
@@ -90,13 +94,13 @@ export class EditableLibraryManager extends LibraryManager {
 
   public getMutableLibraries(): LibraryHandle<IMutableLibrary>[] {
     return this._libraries.filter(
-      (handle) => handle && typeof handle.library["mute"] === "function",
+      (handle) => handle && hasMethod(handle.library, "mute"),
     ) as LibraryHandle<IMutableLibrary>[];
   }
 
   private _getRunnerLibraries(): LibraryHandle<IRunnerLibrary>[] {
     return this._libraries.filter(
-      (handle) => handle && typeof handle.library["__run"] === "function",
+      (handle) => handle && hasMethod(handle.library, "__run"),
     ) as LibraryHandle<IRunnerLibrary>[];
   }
 }

packages/core/src/core/core.ts

@@ -8,6 +8,7 @@ import {
   InitContext,
   type LibraryHandle,
   LibraryStatusEnum,
+  NfNotInitializedException,
 } from "@nanoforge/common";
 
 import { type ApplicationConfig } from "../application/application-config";
@@ -19,8 +20,8 @@ import { ConfigRegistry } from "../config/config-registry";
 export class Core {
   private readonly config: ApplicationConfig;
   private readonly context: ApplicationContext;
-  private options: IApplicationOptions;
-  private _configRegistry: ConfigRegistry;
+  private options?: IApplicationOptions;
+  private _configRegistry?: ConfigRegistry;
 
   constructor(config: ApplicationConfig, context: ApplicationContext) {
     this.config = config;
@@ -34,6 +35,8 @@ export class Core {
   }
 
   public async run(): Promise<void> {
+    if (!this.options) throw new NfNotInitializedException("Core");
+
     const context = this.getExecutionContext();
     const clientContext = this.getClientContext();
     const libraries = this.config.libraryManager.getExecutionLibraries();
@@ -58,6 +61,8 @@ export class Core {
   }
 
   private getInitContext(options: IRunOptions): InitContext {
+    if (!this._configRegistry) throw new NfNotInitializedException("Core");
+
     return new InitContext(this.context, this.config.libraryManager, this._configRegistry, options);
   }
 

packages/ecs/.prettierignore

@@ -4,6 +4,5 @@ package-lock.json
 yarn.lock
 bun.lock
 
-*.js
 *.d.ts
 build

packages/ecs/src/ecs-library.ts

@@ -6,12 +6,11 @@ import {
   type InitContext,
 } from "@nanoforge/common";
 
-import type { MainModule, Registry } from "../lib";
-import { Module } from "../lib";
+import { type MainModule, Module, type Registry } from "../lib";
 
 export class ECSLibrary extends BaseComponentSystemLibrary {
-  private module: MainModule;
-  private _registry: Registry;
+  private module?: MainModule;
+  private _registry?: Registry;
 
   private readonly path: string = "libecs.wasm";
 
@@ -33,10 +32,12 @@ export class ECSLibrary extends BaseComponentSystemLibrary {
   }
 
   async __run(ctx: Context): Promise<void> {
+    if (!this._registry) this.throwNotInitializedError();
     this._registry.runSystems(ctx);
   }
 
   get registry(): Registry {
+    if (!this._registry) this.throwNotInitializedError();
     return this._registry;
   }
 }

packages/ecs/src/index.ts

@@ -1,4 +1,4 @@
-import "@lib/libecs.wasm";
+import "../lib/libecs.wasm";
 
 export { ECSLibrary } from "./ecs-library";
 export type { Component, System, Registry } from "../lib";

packages/ecs/tsconfig.build.json

@@ -4,7 +4,6 @@
     "outDir": ".",
     "rootDir": ".",
     "paths": {
-      "@lib": ["./lib"],
       "@nanoforge/common": ["../common"]
     }
   },

packages/graphics-2d/src/graphics-2d.library.ts

@@ -3,13 +3,14 @@ import { BaseGraphicsLibrary, type InitContext } from "@nanoforge/common";
 import { Graphics } from ".";
 
 export class Graphics2DLibrary extends BaseGraphicsLibrary {
-  private _stage: Graphics.Stage;
+  private _stage?: Graphics.Stage;
 
   get __name(): string {
     return "Graphics2DLibrary";
   }
 
   get stage(): Graphics.Stage {
+    if (!this._stage) this.throwNotInitializedError();
     return this._stage;
   }
 

packages/input/src/input.library.ts

@@ -4,7 +4,7 @@ import { InputHandler } from "./input-handler";
 import { type InputEnum } from "./input.enum";
 
 export class InputLibrary extends BaseInputLibrary {
-  private _inputHandler: InputHandler;
+  private _inputHandler?: InputHandler;
 
   get __name(): string {
     return "InputLibrary";
@@ -15,10 +15,12 @@ export class InputLibrary extends BaseInputLibrary {
   }
 
   public isKeyPressed(key: InputEnum): boolean {
+    if (!this._inputHandler) this.throwNotInitializedError();
     return this._inputHandler.getKeyStatus(key);
   }
 
   public getPressedKeys(): InputEnum[] {
+    if (!this._inputHandler) this.throwNotInitializedError();
     const res: InputEnum[] = [];
     for (const rawKey in this._inputHandler.inputs) {
       const key = rawKey as InputEnum;

packages/music/src/music.library.ts

@@ -1,8 +1,8 @@
 import { BaseMusicLibrary, NfNotFound } from "@nanoforge/common";
 
 export class MusicLibrary extends BaseMusicLibrary {
-  private muted: boolean;
-  private musics: Map<string, HTMLAudioElement>;
+  private muted: boolean = true;
+  private musics?: Map<string, HTMLAudioElement>;
   private current: HTMLAudioElement | null = null;
 
   get __name(): string {
@@ -15,17 +15,17 @@ export class MusicLibrary extends BaseMusicLibrary {
   }
 
   public mute(): void {
+    if (!this.musics) this.throwNotInitializedError();
     this.muted = !this.muted;
-    for (const key in this.musics) {
-      const element = this.musics[key];
-
+    for (const [, element] of this.musics) {
       if (element) {
         element.muted = this.muted;
       }
     }
   }
 
   public play(music: string): void {
+    if (!this.musics) this.throwNotInitializedError();
     const musicElement = this.musics.get(music);
 
     if (musicElement) {
@@ -44,6 +44,7 @@ export class MusicLibrary extends BaseMusicLibrary {
   }
 
   public load(music: string, file: string) {
+    if (!this.musics) this.throwNotInitializedError();
     const element = new Audio(file);
     if (element) {
       element.muted = this.muted;

packages/sound/src/sound.library.ts

@@ -1,8 +1,8 @@
 import { BaseSoundLibrary, NfNotFound } from "@nanoforge/common";
 
 export class SoundLibrary extends BaseSoundLibrary {
-  private muted: boolean;
-  private sounds: Map<string, HTMLAudioElement>;
+  private muted: boolean = true;
+  private sounds?: Map<string, HTMLAudioElement>;
 
   get __name(): string {
     return "NfSound";
@@ -14,17 +14,17 @@ export class SoundLibrary extends BaseSoundLibrary {
   }
 
   public mute(): void {
+    if (!this.sounds) this.throwNotInitializedError();
     this.muted = !this.muted;
-    for (const key in this.sounds) {
-      const element = this.sounds[key];
-
+    for (const [, element] of this.sounds) {
       if (element) {
         element.muted = this.muted;
       }
     }
   }
 
   public play(sound: string): void {
+    if (!this.sounds) this.throwNotInitializedError();
     const soundElement = this.sounds.get(sound);
 
     if (soundElement) {
@@ -40,6 +40,7 @@ export class SoundLibrary extends BaseSoundLibrary {
   }
 
   public load(sound: string, file: string) {
+    if (!this.sounds) this.throwNotInitializedError();
     const element = new Audio(file);
     if (element) {
       element.muted = this.muted;

packages/tsconfig.build.json

@@ -3,7 +3,6 @@
     "composite": true,
     "module": "commonjs",
     "declaration": true,
-    "noImplicitAny": false,
     "skipLibCheck": true,
     "noUnusedLocals": false,
     "importHelpers": true,
@@ -18,7 +17,6 @@
     "strict": true,
     "strictNullChecks": true,
     "forceConsistentCasingInFileNames": true,
-    "strictPropertyInitialization": false,
     "types": ["node"]
   }
 }