slifer 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Mohammed Salim
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,59 @@
+# Slifer : Native Typescript Game Framework
+
+<p align="center">
+    <img width="80%" src="./logo-alpha.png">
+</p>
+
+> [!CAUTION]
+> Slifer is currently in alpha. Use at your own risk.
+>
+
+> [!NOTE]
+> Not all basic features have been implemented. Many are missing such as window customization.
+> As such, I recommend waiting for a beta release of Slifer before using it for a long term project.
+
+Slifer is a game framework made to allow users to code games in typescript. The framework uses bun and SDL2 under the hood to allow your game to render and build natively to desktop.
+
+## Contents
+- [Goals](#goals)
+- [Current Features](#current-features)
+- [Future Features](#future-features)
+- [Example](#example)
+
+## Goals
+
+- Contain all basic game framework implementations. Such as drawing images, drawing text and making animations from a sprite sheet.
+- Provide an easy transition from web development to game development.
+- Create an easy to use framework. Slifer should handle the bulk of the work
+- Keep updates consistent.
+
+## Current Features
+- Create a native desktop window with custom title and size.
+- Handle both keyboard and mouse inputs
+- Load and draw images onto the window
+
+## Future Features
+- Audio Implementation
+- Animation library
+- Save file library
+
+## Example
+```ts
+import Slifer from Slifer;
+
+Slifer.createWindow("Example Window", 640, 480);
+
+const bg = Slifer.Graphics.makeColor(36, 36, 36, 255);
+
+while (!Slifer.shouldClose()) {
+    Slifer.Graphics.setBackground(bg);
+
+    if (Slifer.Keyboard.isPressed('escape')) {
+        Slifer.isRunning = false;
+    }
+
+    Slifer.Graphics.render();
+}
+
+Slifer.quit();
+```

package/index.ts

@@ -0,0 +1,4 @@
+import { SliferClass } from "./src/slifer";
+
+const Slifer = new SliferClass();
+export default Slifer;

package/package.json

@@ -0,0 +1,14 @@
+{
+  "name": "slifer",
+  "version": "0.1.2",
+  "description": "A game framework made for bun and typescript",
+  "module": "index.ts",
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typedoc": "^0.26.7"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "type": "module"
+}

package/src/ffi.ts

@@ -0,0 +1,213 @@
+import { dlopen, FFIType, suffix } from 'bun:ffi';
+
+let libSDLImport;
+let libImageImport;
+let libTTFImport;
+let libGFXImport;
+
+if (process.platform == "win32") {
+    //@ts-expect-error
+    libSDLImport = await import("../libs/libSDL2.dll");
+    //@ts-expect-error
+    libImageImport = await import("../libs/libSDL2_image.dll");
+    //@ts-expect-error
+    libTTFImport = await import("../libs/libSDL2_ttf.dll");
+} else if (process.platform == "darwin") {
+    //@ts-expect-error
+    libSDLImport = await import("../libs/libSDL2.dylib");
+    //@ts-expect-error
+    libImageImport = await import("../libs/libSDL2_image.dylib");
+    //@ts-expect-error
+    libTTFImport = await import("../libs/libSDL2_ttf.dylib");
+}
+
+export const libsdl = dlopen(libSDLImport.default, {
+    SDL_Init: {
+        args: [FFIType.int],
+        returns: FFIType.int
+    },
+    SDL_GetRevision: {
+        returns: 'cstring'
+    },
+    SDL_CreateWindow: {
+        args: ['cstring', 'int', 'int', 'int', 'int', 'u32'],
+        returns: 'pointer'
+    },
+    SDL_CreateRenderer: {
+        args: ['pointer', 'int', 'u32'],
+        returns: 'pointer'
+    },
+    SDL_GetDesktopDisplayMode: {
+        args: ['int', 'pointer'],
+        returns: 'int'
+    },
+    SDL_GetDisplayOrientation: {
+        args: ['int'],
+        returns: 'int'
+    },
+    SDL_SetWindowFullscreen: {
+        args: ['pointer', 'u32'],
+        returns: 'int'
+    },
+    SDL_PollEvent: {
+        args: ['pointer'],
+        returns: 'int'
+    },
+    SDL_RenderClear: {
+        args: ['pointer'],
+        returns: 'int'
+    },
+    SDL_RenderCopy: {
+        args: ['pointer', 'pointer', 'pointer', 'pointer'],
+        returns: 'int'
+    },
+    SDL_RenderPresent: {
+        args: ['pointer'],
+        returns: 'void'
+    },
+    SDL_CreateTextureFromSurface: {
+        args: ['pointer', 'pointer'],
+        returns: 'pointer'
+    },
+    SDL_DestroyRenderer: {
+        args: ['pointer'],
+        returns: 'void'
+    },
+    SDL_DestroyWindow: {
+        args: ['pointer'],
+        returns: 'void'
+    },
+    SDL_Quit: {
+        returns: 'void'
+    },
+    SDL_GetKeyName: {
+        args: ['int'],
+        returns: 'cstring'
+    },
+    SDL_GetKeyFromScancode: {
+        args: ['int'],
+        returns: 'int'
+    },
+    SDL_GetPerformanceCounter: {
+        returns: 'u64'
+    },
+    SDL_GetPerformanceFrequency: {
+        returns: 'u64'
+    },
+    SDL_QueryTexture :{
+        args: ['pointer', 'pointer', 'pointer', 'pointer', 'pointer'],
+        returns: 'int'
+    },
+    SDL_GetMouseState: {
+        args: ['pointer', 'pointer'],
+        returns: 'u32'
+    },
+    SDL_CreateColorCursor: {
+        args: ['pointer', 'int', 'int'],
+        returns: 'pointer'
+    },
+    SDL_SetCursor: {
+        args: ['pointer'],
+        returns: 'void'
+    },
+    SDL_SetRenderDrawColor: {
+        args: ['pointer', 'int', 'int', 'int', 'int'],
+        returns: 'void'
+    },
+    SDL_RenderFillRect: {
+        args: ['pointer', 'pointer'],
+        returns: 'bool'
+    },
+    SDL_GetWindowPosition: {
+        args: ['pointer', 'pointer', 'pointer'],
+        returns: 'void'
+    },
+    SDL_SetWindowPosition: {
+        args: ['pointer', 'int', 'int'],
+        returns: 'void'
+    },
+    SDL_SetWindowHitTest: {
+        args: ['pointer', FFIType.function, 'pointer'],
+        returns: 'int'
+    },
+    SDL_GetWindowSize: {
+        args: ['pointer', 'pointer', 'pointer'],
+        returns: 'void'
+    },
+    SDL_CreateSystemCursor: {
+        args:['int'],
+        returns: 'pointer'
+    },
+    SDL_GetError: {
+        returns: 'cstring'
+    },
+    SDL_SetHint: {
+        args: ['cstring', 'cstring'],
+        returns: 'bool'
+    },
+    SDL_MinimizeWindow: {
+        args: ['pointer'],
+        returns: 'void'
+    },
+    SDL_GetShapedWindowMode: {
+        args: ['pointer', 'pointer'],
+        returns: 'int'
+    },
+    SDL_CreateShapedWindow: {
+        args: ['cstring', 'int', 'int', 'int', 'int', 'u32'],
+        returns: 'pointer'
+    },
+    SDL_SetWindowShape: {
+        args: ['pointer', 'pointer', 'pointer'],
+        returns: 'int'
+    },
+    SDL_SetWindowIcon: {
+        args: ['pointer', 'pointer'],
+        returns: 'void'
+    },
+    SDL_RaiseWindow: {
+        args: ['pointer'],
+        returns: 'void'
+    },
+    SDL_RenderCopyEx: {
+        args: ['pointer', 'pointer', 'pointer', 'pointer', 'double', 'pointer', 'int'],
+        returns: 'int'
+    }
+})
+
+export const libimage = dlopen(libImageImport.default, {
+    IMG_Init: {
+        args: ['int'],
+        returns: 'int'
+    },
+    IMG_Load: {
+        args: ['cstring'],
+        returns: 'pointer'
+    }
+})
+
+export const libttf = dlopen(libTTFImport.default, {
+    TTF_Init: {
+        returns: 'int'
+    },
+    TTF_OpenFont: {
+        args: ['cstring', 'int'],
+        returns: 'pointer'
+    },
+    TTF_RenderText_Solid: {
+        args: ['pointer', 'cstring', 'u32'],
+        returns: 'pointer'
+    },
+    TTF_SizeText: {
+        args: ['pointer', 'cstring', 'pointer', 'pointer'],
+        returns: 'int'
+    },
+    TTF_Quit: {
+        returns: 'void'
+    },
+    TTF_CloseFont: {
+        args: ['pointer'],
+        returns: 'void'
+    }
+
+})

package/src/global.ts

@@ -0,0 +1,10 @@
+import { type Pointer } from 'bun:ffi';
+
+class Global {
+
+    static ptrWindow : Pointer;
+    static ptrRenderer : Pointer;
+    static ptrFont : Pointer;
+}
+
+export default Global;

package/src/modules/graphics.ts

@@ -0,0 +1,156 @@
+import { libimage, libsdl, libttf } from "../ffi";
+import Global from "../global";
+import { type Pointer, ptr } from 'bun:ffi';
+import path from 'path';
+
+class Graphics {
+    /**
+     * Slifers draw function. Used to draw everything to the screen.
+     */
+    render() {
+        libsdl.symbols.SDL_RenderPresent(Global.ptrRenderer);
+    }
+
+    /**
+     * Create a new color. All values are from 0-255
+     * 
+     * @param r red value 
+     * @param g green value
+     * @param b blue value
+     * @param a alpha value
+     * @returns Color object
+     */
+    makeColor(r: number, g: number, b: number, a: number) {
+        const _color = new Color(r, g, b, a);
+        return _color;
+    }
+
+    /**
+     * Sets the background of the window to a color of choice. 
+     * 
+     * Make sure this is put in the top level of the while loop
+     * as it will clear the renderer.
+     * 
+     * @param color Color object. Make using Slifer.Graphics.makeColor
+     */
+    setBackground(color: Color) {
+        libsdl.symbols.SDL_SetRenderDrawColor(Global.ptrRenderer, color.r, color.g, color.b, color.a);
+        libsdl.symbols.SDL_RenderClear(Global.ptrRenderer);
+    }
+
+    /**
+     * Loads a new image
+     * 
+     * @param path string path to image
+     * @returns Image ready to draw
+     */
+    loadImage(path: string) : Image {
+        const _path = Buffer.from(path + "\x00");
+        const surface = libimage.symbols.IMG_Load(_path);
+        if (surface == null) throw `Image failed to load`;
+        const texture = libsdl.symbols.SDL_CreateTextureFromSurface(Global.ptrRenderer, surface);
+        if (texture == null) throw `Image failed to be created`;
+        return new Image(texture);
+    }
+
+    /**
+     * Method to draw the image to the screen
+     * 
+     * @param image Image object to draw. Made using Slifer.Graphics.loadImage
+     * @param x x position to draw image
+     * @param y y position to draw image
+     * @param rotation (optional) rotation of image
+     * @param xs (optional) scale of x axis
+     * @param ys (optional) scale of y axis
+     * @param flip (optional) horizontal flip
+     */
+    draw(image: Image, x: number, y: number, rotation?: number, xs?: number, ys?: number, flip?: true) {
+        const _dest = new Uint32Array(4);
+        const wArr = new Uint32Array(1);
+        const hArr = new Uint32Array(1);
+        libsdl.symbols.SDL_QueryTexture((image as any).pointer, null, null, ptr(wArr), ptr(hArr));
+        _dest[0] = x;
+        _dest[1] = y;
+        _dest[2] = wArr[0] * (xs ? xs : 1);
+        _dest[3] = hArr[0] * (ys ? ys : 1);
+        const _center = new Uint32Array(2);
+        _center[0] = _dest[2] / 2;
+        _center[1] = _dest[3] / 2;
+        libsdl.symbols.SDL_RenderCopyEx(Global.ptrRenderer, (image as any).pointer, null, ptr(_dest), rotation ? rotation : 0, ptr(_center), flip ? Number(flip) : 0);
+    }
+
+    /**
+     * Method to draw text to the screen
+     * 
+     * @param text the string of text to print
+     * @param x x position
+     * @param y y position
+     * @param color color of text. Made using Slifer.Graphics.makeColor.
+     */
+    print(text: string, x: number, y: number, color: Color) {
+
+        // Create text buffer
+        const textBuffer = Buffer.from(text+"\x00");
+
+        // Get width and height of text        
+        const wArr = new Uint32Array(1);
+        const hArr = new Uint32Array(1);
+        libttf.symbols.TTF_SizeText(Global.ptrFont,textBuffer , ptr(wArr), ptr(hArr));
+
+        // Define color
+        const _col = ((color.r << 0) + (color.g << 8) + (color.b << 16));
+
+        // Create texture
+        const surface = libttf.symbols.TTF_RenderText_Solid(Global.ptrFont, textBuffer, _col);
+        if (surface == null) throw `Surface creation failed on print`;
+        const texture = libsdl.symbols.SDL_CreateTextureFromSurface(Global.ptrRenderer, surface);
+        if (texture == null) throw `Texture creation failed on print`;
+
+        // Create destination
+        const destArr = new Uint32Array(4);
+        destArr[0] = x;
+        destArr[1] = y;
+        destArr[2] = wArr[0];
+        destArr[3] = hArr[0];
+
+        // Draw text
+        libsdl.symbols.SDL_RenderCopy(Global.ptrRenderer, texture, null, ptr(destArr));        
+    }
+
+    /**
+     * Sets the font to a ttf file in your project
+     * 
+     * @param path relative path to font
+     * @param pt size of text
+     */
+    setFont(path: string, pt: number) {
+        const tempFont = libttf.symbols.TTF_OpenFont(Buffer.from(path+"\x00"), pt);
+        if (tempFont == null) throw `Font loading failed`;
+        Global.ptrFont = tempFont;
+    }
+}
+
+class Image {
+
+    private pointer;
+    
+    constructor(texture: Pointer) {
+        this.pointer = texture;
+    }
+}
+
+class Color {
+    readonly r;
+    readonly g;
+    readonly b;
+    readonly a;
+
+    constructor(r: number, g: number, b: number, a: number) {
+        this.r = r;
+        this.g = g;
+        this.b = b;
+        this.a = a;
+    }
+}
+
+export default Graphics;

package/src/modules/keyboard.ts

@@ -0,0 +1,78 @@
+class Keyboard {
+
+    static downKeyMap = new Map<string, boolean>();
+    static pressedKeyMap = new Map<string, boolean>();
+    static releasedKeyMap = new Map<string, boolean>();
+    
+    static setKeyDown(key: string) {
+        this.downKeyMap.set(key, true);
+        this.releasedKeyMap.set(key, false);
+    }
+
+    static setKeyUp(key: string) {
+        this.downKeyMap.set(key, false);
+        this.pressedKeyMap.set(key, false);
+    }
+
+    /**
+     * 
+     * @param key string of key
+     * @returns if the key is being held down
+     */
+    isDown(key: keys) {
+        const _state = Keyboard.downKeyMap.get(key);
+        if (_state == undefined) return false
+
+        return _state;
+    }
+
+    /**
+     * 
+     * @param key string of key
+     * @returns if key is pressed. Returns only once
+     */
+    isPressed(key: keys) {
+        const _pressedState = Keyboard.pressedKeyMap.get(key);
+        const _downState = Keyboard.downKeyMap.get(key);
+
+        if (_downState == true) {
+            if (_pressedState == false || _pressedState == undefined) {
+                Keyboard.pressedKeyMap.set(key, true);
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * 
+     * @param key string of key
+     * @returns if key is released. Returns only once
+     */
+    isReleased(key: keys) {
+        const _releasedState = Keyboard.releasedKeyMap.get(key);
+        const _downState = Keyboard.downKeyMap.get(key);
+
+        if (_downState == false) {
+            if (_releasedState == false || undefined) {
+                Keyboard.releasedKeyMap.set(key, true);
+                return true;
+            }
+        }
+
+        return false;
+    }
+}
+
+type keys = 'a' |'b' |'c' |'d' |'e' |'f' |'g' |'h' |'i' |'j' |'k' |'l' |'m' |'n' |'o' |'p' |'q' |'r' |'s' |'t' |'u' |'v' |'w' |'x' |'y' |'z' |
+'1' |'2' |'3' |'4' |'5' |'6' |'7' |'8' |'9' |'0' |
+'space' |
+'caps lock' |
+'tab' |
+'left shift' |
+'right shift' |
+'left ctrl' |
+'escape';
+
+export default Keyboard;

package/src/modules/mouse.ts

@@ -0,0 +1,100 @@
+import { libsdl } from "../ffi";
+import { ptr } from 'bun:ffi';
+
+class Mouse {
+
+    static downKeyMap = new Map<string, boolean>();
+    static pressedKeyMap = new Map<string, boolean>();
+    static releasedKeyMap = new Map<string, boolean>();
+    
+    static setButtonDown(button: number) {
+
+        let key : string = '';
+        if (button == 1) {
+            key = "left";
+        } else if (button == 2) {
+            key = "middle";
+        } else {
+            key = "right";
+        }
+
+        this.downKeyMap.set(key, true);
+        this.releasedKeyMap.set(key, false);
+    }
+
+    static setButtonUp(button: number) {
+
+        let key : string = '';
+        if (button == 1) {
+            key = "left";
+        } else if (button == 2) {
+            key = "middle";
+        } else {
+            key = "right";
+        }
+        
+        this.downKeyMap.set(key, false);
+        this.pressedKeyMap.set(key, false);
+    }
+
+    /**
+     * 
+     * @param button string of button
+     * @returns if the button is being held down
+     */
+    isDown(button: buttons) {
+        const _state = Mouse.downKeyMap.get(button);
+        if (_state == undefined) return false
+
+        return _state;
+    }
+
+    /**
+     * 
+     * @param button string of button
+     * @returns if button is pressed. Returns only once
+     */
+    isPressed(button: buttons) {
+        const _pressedState = Mouse.pressedKeyMap.get(button);
+        const _downState = Mouse.downKeyMap.get(button);
+
+        if (_downState == true) {
+            if (_pressedState == false || _pressedState == undefined) {
+                Mouse.pressedKeyMap.set(button, true);
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * 
+     * @param button string of button
+     * @returns if button is released. Returns only once
+     */
+    isReleased(button: buttons) {
+        const _releasedState = Mouse.releasedKeyMap.get(button);
+        const _downState = Mouse.downKeyMap.get(button);
+
+        if (_downState == false) {
+            if (_releasedState == false || undefined) {
+                Mouse.releasedKeyMap.set(button, true);
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    getPosition() {
+        const xArr = new Uint32Array(1);
+        const yArr = new Uint32Array(1);
+        libsdl.symbols.SDL_GetMouseState(ptr(xArr), ptr(yArr));
+        return {x: xArr[0], y: yArr[0]};
+    }
+}
+
+type buttons = 'left' | 'middle' | 'right';
+
+export default Mouse;

package/src/slifer.ts

@@ -0,0 +1,115 @@
+import { libimage, libsdl, libttf } from "./ffi";
+import Global from "./global";
+import { ptr } from 'bun:ffi';
+import Graphics from "./modules/graphics";
+import Keyboard from "./modules/keyboard";
+import Mouse from "./modules/mouse";
+
+export class SliferClass {
+
+    isRunning : boolean = true;
+
+    // Modules
+    Graphics = new Graphics();
+    Keyboard = new Keyboard();
+    Mouse = new Mouse();
+
+    constructor() {
+        const baseInit = libsdl.symbols.SDL_Init(0x00000020);
+        if (baseInit != 0) throw `SDL failed to initialize`;
+
+        const imageInit = libimage.symbols.IMG_Init(3);
+        if (imageInit != 3) throw `SDL Image failed to initialize`;
+
+        const ttfInit = libttf.symbols.TTF_Init();
+        if (ttfInit != 0) throw `SDL TTF failed to initialize`;
+
+        if (process.platform == "darwin") {
+            const tempFont = libttf.symbols.TTF_OpenFont(Buffer.from("/System/Library/Fonts/SFNSMono.ttf"), 12);
+            if (tempFont == null) throw `Default font loading failed`;
+            Global.ptrFont = tempFont;
+        }
+        
+    }
+
+    /**
+     * 
+     * @param title Title of window
+     * @param width Width of window
+     * @param height Height of window
+     */
+    createWindow(title: string, width: number, height: number) : void {
+        // Creating cstring buffer from string
+        const _title = Buffer.from(title + "\x00");
+
+        // Creating window pointer
+        const _win = libsdl.symbols.SDL_CreateWindow(_title, 0x2FFF0000, 0x2FFF0000, width, height, 0);
+        if (_win == null) throw `Window creation failed`;
+        Global.ptrWindow = _win;
+
+        // Creating renderer pointer
+        const _ren = libsdl.symbols.SDL_CreateRenderer(Global.ptrWindow, -1, 0);
+        if (_ren == null) throw `Renderer Creation failed`;
+        Global.ptrRenderer = _ren;
+
+        }
+
+    /**
+     * 
+     * @returns if the window should close
+     */
+    shouldClose() : boolean {
+
+        // Clear the renderer
+        libsdl.symbols.SDL_RenderClear(Global.ptrRenderer);
+
+        // Poll Events
+        const eventArray = new Uint16Array(32);
+        const isEvent = libsdl.symbols.SDL_PollEvent(ptr(eventArray));
+
+        if (isEvent) {
+            switch (eventArray[0]) {
+                // Quit event
+                case 256:
+                    this.isRunning = false;
+                    break;
+                // Keydown event
+                case 768:
+                    const _dscancode = eventArray[8];
+                    const _dkey = libsdl.symbols.SDL_GetKeyFromScancode(_dscancode);
+                    const _dname = libsdl.symbols.SDL_GetKeyName(_dkey);
+                    Keyboard.setKeyDown(_dname.toString().toLowerCase());
+                    break;
+                // Keyup event
+                case 769:
+                    const _uscancode = eventArray[8];
+                    const _ukey = libsdl.symbols.SDL_GetKeyFromScancode(_uscancode);
+                    const _uname = libsdl.symbols.SDL_GetKeyName(_ukey);
+                    Keyboard.setKeyUp(_uname.toString().toLowerCase());
+                    break;
+                // Mouse down event
+                case 1025:
+                    const _dbtn = eventArray[8] - 256;
+                    Mouse.setButtonDown(_dbtn);
+                    break;
+                // Mouse up event
+                case 1026:
+                    const _ubtn = eventArray[8];
+                    Mouse.setButtonUp(_ubtn);
+                    break;
+            }
+        }
+
+        return !this.isRunning;
+    }
+
+    /**
+     * Slifers quit method
+     */
+    quit() {
+        libttf.symbols.TTF_CloseFont(Global.ptrFont);
+        libsdl.symbols.SDL_DestroyRenderer(Global.ptrRenderer);
+        libsdl.symbols.SDL_DestroyWindow(Global.ptrWindow);
+        libsdl.symbols.SDL_Quit();
+    }
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    // Enable latest features
+    "lib": ["ESNext", "DOM"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleDetection": "force",
+    "jsx": "react-jsx",
+    "allowJs": true,
+
+    // Bundler mode
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    // Best practices
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+
+    // Some stricter flags (disabled by default)
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noPropertyAccessFromIndexSignature": false
+  }
+}