@noxfly/noxus 3.0.0-dev.4 → 3.0.0-dev.5

package/src/utils/radix-tree.ts

@@ -1,243 +0,0 @@
-/**
- * @copyright 2025 NoxFly
- * @license MIT
- * @author NoxFly
- */
-
-/**
- *
- */
-type Params = Record<string, string>;
-
-/**
- * Represents a search result in the Radix Tree.
- */
-interface ISearchResult<T> {
-    node: RadixNode<T>;
-    params: Params;
-}
-
-/**
- * Represents a node in the Radix Tree.
- * The represents a path segment
- */
-class RadixNode<T> {
-    public segment: string;
-    public children: RadixNode<T>[] = [];
-    public value?: T;
-    public isParam: boolean;
-    public paramName?: string;
-
-    /**
-     * Creates a new RadixNode.
-     * @param segment - The segment of the path this node represents.
-     */
-    constructor(segment: string) {
-        this.segment = segment;
-        this.isParam = segment.startsWith(":");
-
-        if(this.isParam) {
-            this.paramName = segment.slice(1);
-        }
-    }
-
-    /**
-     * Matches a child node against a given segment.
-     * This method checks if the segment matches any of the children nodes.
-     * @param segment - The segment to match against the children of this node.
-     * @returns A child node that matches the segment, or undefined if no match is found.
-     */
-    public matchChild(segment: string): RadixNode<T> | undefined {
-        for(const child of this.children) {
-            if(child.isParam || segment.startsWith(child.segment))
-                return child; // param match
-        }
-
-        return undefined;
-    }
-
-    /**
-     * Finds a child node that matches the segment exactly.
-     * This method checks if there is a child node that matches the segment exactly.
-     * @param segment - The segment to find an exact match for among the children of this node.
-     * @returns A child node that matches the segment exactly, or undefined if no match is found.
-     */
-    public findExactChild(segment: string): RadixNode<T> | undefined {
-        return this.children.find(c => c.segment === segment);
-    }
-
-    /**
-     * Adds a child node to this node's children.
-     * This method adds a new child node to the list of children for this node.
-     * @param node - The child node to add to this node's children.
-     */
-    public addChild(node: RadixNode<T>): void {
-        this.children.push(node);
-    }
-}
-
-/**
- *
- */
-export class RadixTree<T> {
-    private readonly root = new RadixNode<T>("");
-
-    /**
-     * Inserts a path and its associated value into the Radix Tree.
-     * This method normalizes the path and inserts it into the tree, associating it with
-     * @param path - The path to insert into the tree.
-     * @param value - The value to associate with the path.
-     */
-    public insert(path: string, value: T): void {
-        const segments = this.normalize(path);
-        this.insertRecursive(this.root, segments, value);
-    }
-
-    /**
-     * Recursively inserts a path into the Radix Tree.
-     * This method traverses the tree and inserts the segments of the path, creating new nodes
-     * @param node - The node to start inserting from.
-     * @param segments - The segments of the path to insert.
-     * @param value - The value to associate with the path.
-     */
-    private insertRecursive(node: RadixNode<T>, segments: string[], value: T): void {
-        if(segments.length === 0) {
-            node.value = value;
-            return;
-        }
-
-        const segment = segments[0] ?? "";
-
-        let child = node.children.find(c =>
-            c.isParam === segment.startsWith(":") &&
-            (c.isParam || c.segment === segment)
-        );
-
-        if(!child) {
-            child = new RadixNode<T>(segment);
-            node.addChild(child);
-        }
-
-        this.insertRecursive(child, segments.slice(1), value);
-    }
-
-    /**
-     * Searches for a path in the Radix Tree.
-     * This method normalizes the path and searches for it in the tree, returning the node
-     * @param path - The path to search for in the Radix Tree.
-     * @returns An ISearchResult containing the node and parameters if a match is found, otherwise undefined.
-     */
-    public search(path: string): ISearchResult<T> | undefined {
-        const segments = this.normalize(path);
-        return this.searchRecursive(this.root, segments, {});
-    }
-
-    /**
-     * Collects all values in the subtree rooted at the given node.
-     * This method traverses the subtree starting from the given node and collects all values
-     * @param node - The node to start collecting values from.
-     * @param values - An array to store the collected values. This parameter is optional and can be used for recursive calls.
-     * @returns An array of all values found in the subtree rooted at the given node.
-     */
-    public collectValues(): T[];
-    public collectValues(node: RadixNode<T>, values: T[]): T[];
-    public collectValues(node?: RadixNode<T>, values: T[] = []): T[] {
-        if(!node) {
-            node = this.root;
-        }
-
-        if(node.value !== undefined) {
-            values.push(node.value);
-        }
-
-        for(const child of node.children) {
-            this.collectValues(child, values);
-        }
-
-        return values;
-    }
-
-    /**
-     * Recursively searches for a path in the Radix Tree.
-     * This method traverses the tree and searches for the segments of the path, collecting parameters
-     * @param node - The node to start searching from.
-     * @param segments - The segments of the path to search for.
-     * @param params - The parameters collected during the search.
-     * @returns An ISearchResult containing the node and parameters if a match is found, otherwise undefined.
-     */
-    private searchRecursive(node: RadixNode<T>, segments: string[], params: Params): ISearchResult<T> | undefined {
-        if(segments.length === 0) {
-            if(node.value !== undefined) {
-                return {
-                    node: node,
-                    params
-                };
-            }
-
-            return undefined;
-        }
-
-        const [segment, ...rest] = segments;
-
-        // Try static (exact) matches first, then param matches.
-        // This ensures e.g. 'addNote' is preferred over ':id'.
-        const staticChildren: RadixNode<T>[] = [];
-        const paramChildren: RadixNode<T>[] = [];
-
-        for(const child of node.children) {
-            if(child.isParam) {
-                paramChildren.push(child);
-            }
-            else if(segment === child.segment) {
-                staticChildren.push(child);
-            }
-        }
-
-        for(const child of staticChildren) {
-            if(rest.length === 0) {
-                // Only return leaf-level matches (has children for method nodes, or has a value)
-                if(child.value !== undefined || child.children.length > 0) {
-                    return { node: child, params };
-                }
-            }
-
-            const result = this.searchRecursive(child, rest, params);
-            if(result) return result;
-        }
-
-        for(const child of paramChildren) {
-            const paramName = child.paramName!;
-
-            const childParams: Params = {
-                ...params,
-                [paramName]: segment ?? "",
-            };
-
-            if(rest.length === 0) {
-                if(child.value !== undefined || child.children.length > 0) {
-                    return { node: child, params: childParams };
-                }
-            }
-
-            const result = this.searchRecursive(child, rest, childParams);
-            if(result) return result;
-        }
-
-        return undefined;
-    }
-
-    /**
-     * Normalizes a path into an array of segments.
-     * This method removes leading and trailing slashes, splits the path by slashes, and
-     * @param path - The path to normalize.
-     * @returns An array of normalized path segments.
-     */
-    private normalize(path: string): string[] {
-        const segments = path
-            .replace(/^\/+|\/+$/g, "")
-            .split("/")
-            .filter(Boolean);
-
-        return ['', ...segments];
-    }
-}

package/src/utils/types.ts

@@ -1,21 +0,0 @@
-/**
- * @copyright 2025 NoxFly
- * @license MIT
- * @author NoxFly
- */
-
-
-/**
- * Represents a generic type that can be either a class or a function.
- * This is used to define types that can be instantiated or called.
- */
-declare const Type: FunctionConstructor;
-export interface Type<T> extends Function {
-    // eslint-disable-next-line @typescript-eslint/prefer-function-type
-    new (...args: any[]): T;
-}
-
-/**
- * Represents a generic type that can be either a value or a promise resolving to that value.
- */
-export type MaybeAsync<T> = T | Promise<T>;

package/src/window/window-manager.ts

@@ -1,302 +0,0 @@
-/**
- * @copyright 2025 NoxFly
- * @license MIT
- * @author NoxFly
- */
-
-import { BrowserWindow } from 'electron/main';
-import { Injectable } from '../decorators/injectable.decorator';
-import { Logger } from '../utils/logger';
-
-export interface WindowConfig extends Electron.BrowserWindowConstructorOptions {
-    /**
-     * If true, the window expands to fill the work area after creation
-     * using an animated setBounds. The content is loaded only after
-     * the animation completes, preventing the viewbox freeze issue.
-     * @default false
-     */
-    expandToWorkArea?: boolean;
-
-    /**
-     * Duration in ms to wait for the setBounds animation to complete
-     * before loading content. Only used when expandToWorkArea is true.
-     * @default 600
-     */
-    expandAnimationDuration?: number;
-}
-
-export interface WindowRecord {
-    window: BrowserWindow;
-    id: number;
-}
-
-/**
- * @description
- * The events emitted by WindowManager when windows are created, closed, focused, or blurred.
- */
-export type WindowEvent = 'created' | 'closed' | 'focused' | 'blurred';
-
-/**
- * WindowManager is a singleton service that centralizes BrowserWindow lifecycle.
- *
- * Features:
- * - Creates and tracks all application windows.
- * - Handles the animated expand-to-work-area pattern correctly,
- *   loading content only after the animation ends to avoid the viewbox freeze.
- * - Provides convenience methods to get windows by id, get the main window, etc.
- * - Automatically removes windows from the registry on close.
- *
- * @example
- * // In your IApp.onReady():
- * const wm = inject(WindowManager);
- *
- * const win = await wm.create({
- *   width: 600, height: 600, center: true,
- *   expandToWorkArea: true,
- *   webPreferences: { preload: path.join(__dirname, 'preload.js') },
- * });
- *
- * win.loadFile('index.html');
- */
-@Injectable({ lifetime: 'singleton' })
-export class WindowManager {
-    private readonly _windows = new Map<number, BrowserWindow>();
-    private readonly listeners = new Map<WindowEvent, Set<(win: BrowserWindow) => void>>();
-
-    private _mainWindowId: number | undefined;
-
-    // -------------------------------------------------------------------------
-    // Creation
-    // -------------------------------------------------------------------------
-
-    /**
-     * Creates a BrowserWindow, optionally performs an animated expand to the
-     * work area, and registers it in the manager.
-     *
-     * If expandToWorkArea is true:
-     * 1. The window is created at the given initial size (defaults to 600×600, centered).
-     * 2. An animated setBounds expands it to the full work area.
-     * 3. The returned promise resolves only after the animation, so callers
-     *    can safely call win.loadFile() without the viewbox freeze.
-     *
-     * @param config Window configuration.
-     * @param isMain Mark this window as the main window (accessible via getMain()).
-     */
-    public async create(config: WindowConfig, isMain = false): Promise<BrowserWindow> {
-        const {
-            expandToWorkArea = false,
-            expandAnimationDuration = 600,
-            ...bwOptions
-        } = config;
-
-        // show: false by default during creation — we control visibility
-        const win = new BrowserWindow({ show: false, ...bwOptions });
-
-        this._register(win, isMain);
-
-        if (expandToWorkArea) {
-            await this._expandToWorkArea(win, expandAnimationDuration);
-        }
-
-        win.once('ready-to-show', () => win.show());
-
-        Logger.log(`[WindowManager] Created window #${win.id}${isMain ? ' (main)' : ''}`);
-
-        return win;
-    }
-
-    /**
-     * Creates the initial "splash" window that is shown immediately after
-     * app.whenReady(). It is displayed instantly (show: true, no preload
-     * loading) and then expanded to the work area with animation.
-     *
-     * After the animation completes you can call win.loadFile() without
-     * experiencing the viewbox freeze.
-     *
-     * This is the recommended way to get pixels on screen as fast as possible.
-     *
-     * @example
-     * const win = await wm.createSplash({
-     *   webPreferences: { preload: path.join(__dirname, 'preload.js') }
-     * });
-     * win.loadFile('index.html');
-     */
-    public async createSplash(
-        options: Electron.BrowserWindowConstructorOptions & {
-            animationDuration?: number;
-            expandToWorkArea?: boolean;
-        } = {},
-    ): Promise<BrowserWindow> {
-        const {
-            animationDuration = 10,
-            expandToWorkArea = true,
-            ...bwOptions
-        } = options;
-
-        const win = new BrowserWindow({
-            width: 600,
-            height: 600,
-            center: true,
-            show: true,
-            ...bwOptions,
-        });
-
-        this._register(win, true);
-
-        Logger.log(`[WindowManager] Splash window #${win.id} created`);
-
-        if(expandToWorkArea) {
-            await (() => new Promise((r) => setTimeout(r, 500)))();
-            await this._expandToWorkArea(win, animationDuration);
-        }
-
-        return win;
-    }
-
-    // -------------------------------------------------------------------------
-    // Accessors
-    // -------------------------------------------------------------------------
-
-    /** Returns all currently open windows. */
-    public getAll(): BrowserWindow[] {
-        return [...this._windows.values()];
-    }
-
-    /** Returns the window designated as main, or undefined. */
-    public getMain(): BrowserWindow | undefined {
-        return this._mainWindowId !== undefined
-            ? this._windows.get(this._mainWindowId)
-            : undefined;
-    }
-
-    /** Returns a window by its Electron id, or undefined. */
-    public getById(id: number): BrowserWindow | undefined {
-        return this._windows.get(id);
-    }
-
-    /** Returns the number of open windows. */
-    public get count(): number {
-        return this._windows.size;
-    }
-
-    // -------------------------------------------------------------------------
-    // Actions
-    // -------------------------------------------------------------------------
-
-    /** Closes and destroys a window by id. */
-    public close(id: number): void {
-        const win = this._windows.get(id);
-
-        if (!win) {
-            Logger.warn(`[WindowManager] Window #${id} not found`);
-            return;
-        }
-
-        win.destroy();
-    }
-
-    /** Closes all windows. */
-    public closeAll(): void {
-        for (const win of this._windows.values()) {
-            win.destroy();
-        }
-    }
-
-    /**
-     * Sends a message to a specific window via webContents.send.
-     * @param id Target window id.
-     * @param channel IPC channel name.
-     * @param args Payload.
-     */
-    public send(id: number, channel: string, ...args: unknown[]): void {
-        const win = this._windows.get(id);
-        if (!win || win.isDestroyed()) {
-            Logger.warn(`[WindowManager] Cannot send to window #${id}: not found or destroyed`);
-            return;
-        }
-        win.webContents.send(channel, ...args);
-    }
-
-    /**
-     * Broadcasts a message to all open windows.
-     */
-    public broadcast(channel: string, ...args: unknown[]): void {
-        for (const win of this._windows.values()) {
-            if (!win.isDestroyed()) {
-                win.webContents.send(channel, ...args);
-            }
-        }
-    }
-
-    // -------------------------------------------------------------------------
-    // Events
-    // -------------------------------------------------------------------------
-
-    public on(event: WindowEvent, handler: (win: BrowserWindow) => void): () => void {
-        const set = this.listeners.get(event) ?? new Set();
-        set.add(handler);
-        this.listeners.set(event, set);
-        return () => set.delete(handler); // retourne unsubscribe
-    }
-
-    private _emit(event: WindowEvent, win: BrowserWindow): void {
-        this.listeners.get(event)?.forEach(h => h(win));
-    }
-
-    // -------------------------------------------------------------------------
-    // Private
-    // -------------------------------------------------------------------------
-
-    private _register(win: BrowserWindow, isMain: boolean): void {
-        this._windows.set(win.id, win);
-
-        if (isMain && this._mainWindowId === undefined) {
-            this._mainWindowId = win.id;
-        }
-
-        this._emit('created', win);
-
-        win.on('focus', () => this._emit('focused', win));
-        win.on('blur', () => this._emit('blurred', win));
-
-        win.once('closed', () => {
-            this._windows.delete(win.id);
-
-            if (this._mainWindowId === win.id) {
-                this._mainWindowId = undefined;
-            }
-
-            Logger.log(`[WindowManager] Window #${win.id} closed`);
-
-            this._emit('closed', win);
-        });
-    }
-
-    /**
-     * Animates the window to the full work area of the primary display.
-     * Resolves only after the animation is complete, so that content loaded
-     * afterward gets the correct surface size (no viewbox freeze).
-     */
-    private _expandToWorkArea(win: BrowserWindow, animationDuration: number): Promise<void> {
-        return new Promise((resolve) => {
-            win.maximize();
-
-            // Wait for the animation to finish before resolving.
-            // We listen to the 'resize' event which fires once the OS
-            // animation completes, with a safety timeout as fallback.
-            let resolved = false;
-
-            const done = (): void => {
-                if (resolved) {
-                    return;
-                }
-                resolved = true;
-                win.removeListener('resize', done);
-                resolve();
-            };
-
-            win.once('resize', done);
-            setTimeout(done, animationDuration);
-        });
-    }
-}

package/tsconfig.json

@@ -1,29 +0,0 @@
-{
-    "compileOnSave": false,
-    "compilerOptions": {
-        "rootDir": "./src",
-        "baseUrl": "./",
-        "moduleResolution": "node",
-        "target": "ES2020",
-        "module": "CommonJS",
-        "forceConsistentCasingInFileNames": true,
-        "strict": true,
-        "noImplicitOverride": true,
-        "noImplicitReturns": true,
-        "noFallthroughCasesInSwitch": true,
-        "sourceMap": true,
-        "experimentalDecorators": true,
-        "emitDecoratorMetadata": false,
-        "importHelpers": false,
-        "esModuleInterop": true,
-        "useDefineForClassFields": false,
-        "noPropertyAccessFromIndexSignature": false,
-        "noUncheckedIndexedAccess": true,
-        "skipLibCheck": true
-    },
-    "include": [
-        "src/**/*.ts",
-        "src/**/*.d.ts",
-        "node_modules/electron/electron.d.ts"
-    ]
-}

package/tsup.config.ts

@@ -1,50 +0,0 @@
-import { defineConfig, Options } from "tsup";
-
-const copyrights = `
-/**
- * @copyright 2025 NoxFly
- * @license MIT
- * @author NoxFly
- */
-`.trim();
-
-const options: Options = {
-    keepNames: true,
-    minifyIdentifiers: false,
-    name: "noxus",
-    format: ["cjs", "esm"],
-    dts: true,
-    sourcemap: true,
-    clean: false,  // ← false dans le base config
-    outDir: "dist",
-    external: ["electron"],
-    target: "es2020",
-    minify: false,
-    splitting: false,
-    shims: false,
-    treeshake: false,
-    banner: { js: copyrights },
-};
-
-export default defineConfig([
-    {
-        entry: { main: 'src/main.ts' },
-        external: ['electron', 'electron/main'],
-        clean: true,  // ← true uniquement ici
-        ...options,
-    },
-    {
-        entry: { renderer: 'src/renderer.ts' },
-        external: ['electron', 'electron/renderer'],
-        ...options,
-    },
-    {
-        entry: { preload: 'src/preload.ts' },
-        external: ['electron', 'electron/renderer'],
-        ...options,
-    },
-    {
-        entry: { child: 'src/non-electron-process.ts' },
-        ...options,
-    },
-]);