@moostjs/vite 0.4.23

package/README.md

@@ -0,0 +1 @@
+# @moostjs/vite

package/dist/index.cjs

@@ -0,0 +1,252 @@
+'use strict';
+
+var moost = require('moost');
+
+function createAdapterDetector(adapter, onInit) {
+    return {
+        detected: false,
+        regex: new RegExp(`from\\s+["'](@moostjs\\/event-${adapter})["']`),
+        constructor: null,
+        async init() {
+            this.detected = true;
+            const module = await import(`@moostjs/event-${adapter}`);
+            this.constructor = module[`Moost${adapter.charAt(0).toUpperCase() + adapter.slice(1)}`];
+            if (onInit) {
+                onInit(this.constructor);
+            }
+        },
+        compare(c) {
+            if (this.detected && this.constructor) {
+                return (this.constructor === c ||
+                    c instanceof this.constructor ||
+                    c.prototype instanceof this.constructor);
+            }
+            return false;
+        },
+    };
+}
+
+const PLUGIN_NAME = 'moost-vite-dev';
+function gatherAllImporters(moduleNode, visited = new Set()) {
+    if (!moduleNode) {
+        return visited;
+    }
+    if (visited.has(moduleNode)) {
+        return visited;
+    }
+    visited.add(moduleNode);
+    if (moduleNode.importers) {
+        for (const importer of moduleNode.importers) {
+            gatherAllImporters(importer, visited);
+        }
+    }
+    return visited;
+}
+const logger = new moost.EventLogger('', { level: 99 }).createTopic(PLUGIN_NAME);
+function getLogger() {
+    return logger;
+}
+
+function moostRestartCleanup(adapters, cleanupInstances) {
+    const logger = getLogger();
+    const infact = moost.getMoostInfact();
+    const { registry } = infact;
+    infact._cleanup();
+    const mate = moost.getMoostMate();
+    if (cleanupInstances) {
+        for (const key of Object.getOwnPropertySymbols(registry)) {
+            const instance = registry[key];
+            const viteId = mate.read(instance)?.__vite_id;
+            if (viteId && cleanupInstances.has(viteId)) {
+                logger.debug(`🔃 Replacing "${constructorName(instance)}"`);
+                delete registry[key];
+            }
+        }
+        for (const key of Object.getOwnPropertySymbols(registry)) {
+            const instance = registry[key];
+            scanParams(instance, (type) => {
+                if (type === moost.Moost || type instanceof moost.Moost || type.prototype instanceof moost.Moost) {
+                    delete registry[key];
+                    logger.debug(`✖️  Ejecting "${constructorName(instance)}" (depends on re-instantiated "Moost")`);
+                    return true;
+                }
+                for (const adapter of adapters) {
+                    if (adapter.compare(type)) {
+                        delete registry[key];
+                        logger.debug(`✖️  Ejecting "${constructorName(instance)}" (depends on re-instantiated "${adapter.constructor.name}")`);
+                        return true;
+                    }
+                }
+            });
+        }
+        clearDependantRegistry(registry);
+        infact.registry = registry;
+    }
+    moost.getMoostMate()._cleanup();
+    moost.getGlobalWooks(undefined, undefined, 'cleanup');
+}
+function clearDependantRegistry(registry) {
+    const logger = getLogger();
+    const objSet = new Set();
+    let somethingIsDeleted = true;
+    while (somethingIsDeleted) {
+        somethingIsDeleted = false;
+        for (const key of Object.getOwnPropertySymbols(registry)) {
+            const instance = registry[key];
+            objSet.add(Object.getPrototypeOf(instance).constructor);
+        }
+        for (const key of Object.getOwnPropertySymbols(registry)) {
+            const instance = registry[key];
+            scanParams(instance, (type) => {
+                if (!objSet.has(type)) {
+                    delete registry[key];
+                    logger.debug(`✖️  Ejecting "${constructorName(instance)}" (depends on "${type.name}" which is not in registry)`);
+                    somethingIsDeleted = true;
+                    return true;
+                }
+            });
+        }
+    }
+}
+function scanParams(instance, cb) {
+    const mate = moost.getMoostMate();
+    const params = mate.read(instance)?.params;
+    if (params?.length) {
+        for (const param of params) {
+            if (param.type === undefined ||
+                [Array, String, Number, Boolean].includes(param.type)) {
+                continue;
+            }
+            if (cb(param.type)) {
+                break;
+            }
+        }
+    }
+}
+function constructorName(i) {
+    return Object.getPrototypeOf(i).constructor.name;
+}
+
+const REG_HAS_EXPORT_CLASS = /(^\s*@(Injectable|Controller)\()/m;
+const REG_REPLACE_EXPORT_CLASS = /(^\s*@(Injectable|Controller)\()/gm;
+function moostViteDev(options) {
+    const entry = options.entry;
+    let moostMiddleware = null;
+    const adapters = [
+        createAdapterDetector('http', MoostHttp => {
+            MoostHttp.prototype.listen = function (...args) {
+                moostMiddleware = this.getServerCb();
+                setTimeout(() => {
+                    args.filter(a => typeof a === 'function').forEach(a => a());
+                }, 1);
+                return Promise.resolve();
+            };
+        }),
+        createAdapterDetector('cli'),
+        createAdapterDetector('wf'),
+    ];
+    const logger = getLogger();
+    let reloadRequired = false;
+    return {
+        name: PLUGIN_NAME,
+        apply: 'serve',
+        enforce: 'pre',
+        config(cfg) {
+            return {
+                server: {
+                    port: cfg.server?.port || options.port || 3000,
+                    host: cfg.server?.host || options.host,
+                },
+                optimizeDeps: {
+                    noDiscovery: cfg.optimizeDeps?.noDiscovery === undefined ? true : cfg.optimizeDeps.noDiscovery,
+                    exclude: cfg.optimizeDeps?.exclude || ['@swc/core'],
+                },
+                build: {
+                    target: cfg.build?.target || 'node20',
+                    outDir: cfg.build?.outDir || options.outDir || 'dist',
+                    ssr: cfg.build?.ssr || options.entry,
+                    minify: cfg.build?.minify || false,
+                    rollupOptions: {
+                        input: cfg.build?.rollupOptions?.input || options.entry,
+                        output: cfg.build?.rollupOptions?.output || {
+                            format: options.format,
+                            sourcemap: !!(options.sourcemap ?? true),
+                        },
+                    },
+                },
+            };
+        },
+        async transform(code, id) {
+            if (!id.endsWith('.ts')) {
+                return code;
+            }
+            for (const adapter of adapters) {
+                if (!adapter.detected && adapter.regex.test(code)) {
+                    await adapter.init();
+                }
+            }
+            if (REG_HAS_EXPORT_CLASS.test(code)) {
+                code = code.replace(REG_REPLACE_EXPORT_CLASS, '\n@__VITE_ID(import.meta.filename)\n$1');
+                code = `import { __VITE_ID } from 'virtual:vite-id'\n\n${code}`;
+            }
+            return code;
+        },
+        resolveId(id) {
+            if (id === 'virtual:vite-id') {
+                return '\0virtual:vite-id';
+            }
+        },
+        load(id) {
+            if (id === '\0virtual:vite-id') {
+                return `
+          import { getMoostMate } from "moost";
+          const mate = getMoostMate();
+          export function __VITE_ID(id) {
+            return mate.decorate("__vite_id", id)
+          }
+        `;
+            }
+        },
+        async configureServer(server) {
+            moostRestartCleanup(adapters);
+            await server.ssrLoadModule(entry);
+            server.middlewares.use(async (req, res, next) => {
+                if (reloadRequired) {
+                    console.clear();
+                    reloadRequired = false;
+                    logger.debug('🚀 Reloading Moost App...');
+                    await server.ssrLoadModule(entry);
+                    await new Promise(resolve => setTimeout(resolve, 1));
+                }
+                if (moostMiddleware) {
+                    return moostMiddleware(req, res);
+                }
+                next();
+            });
+        },
+        hotUpdate({ file }) {
+            if (file.endsWith('.ts')) {
+                const modules = this.environment.moduleGraph.getModulesByFile(file);
+                if (modules) {
+                    logger.debug(`🔃 Hot update: ${file}`);
+                    const cleanupInstances = new Set();
+                    for (const mod of modules) {
+                        const allImporters = gatherAllImporters(mod);
+                        for (const impModule of allImporters) {
+                            if (impModule.id) {
+                                cleanupInstances.add(impModule.id);
+                            }
+                        }
+                        this.environment.moduleGraph.invalidateModule(mod);
+                    }
+                    moostMiddleware = null;
+                    moostRestartCleanup(adapters, cleanupInstances);
+                    reloadRequired = true;
+                }
+                return [];
+            }
+        },
+    };
+}
+
+exports.moostViteDev = moostViteDev;

package/dist/index.d.ts

@@ -0,0 +1,20 @@
+import { Plugin } from 'vite';
+
+interface TMoostViteDevOptions {
+    entry: string;
+    port?: number;
+    host?: string;
+    outDir?: string;
+    format?: 'cjs' | 'esm';
+    sourcemap?: boolean;
+}
+/**
+ * The main Vite plugin that:
+ * - Detects when moost adapter usage (http, cli, wf).
+ * - Patches `MoostHttp.prototype.listen` in dev mode to register a custom middleware instead of listening on a port.
+ * - Injects a `__VITE_ID()` decorator into exported classes to track them for hot reload cleanup.
+ * - Cleans up internal Moost state upon hot updates, then reloads the SSR entry.
+ */
+declare function moostViteDev(options: TMoostViteDevOptions): Plugin;
+
+export { moostViteDev };

package/dist/index.mjs

@@ -0,0 +1,250 @@
+import { EventLogger, getMoostInfact, getMoostMate, getGlobalWooks, Moost } from 'moost';
+
+function createAdapterDetector(adapter, onInit) {
+    return {
+        detected: false,
+        regex: new RegExp(`from\\s+["'](@moostjs\\/event-${adapter})["']`),
+        constructor: null,
+        async init() {
+            this.detected = true;
+            const module = await import(`@moostjs/event-${adapter}`);
+            this.constructor = module[`Moost${adapter.charAt(0).toUpperCase() + adapter.slice(1)}`];
+            if (onInit) {
+                onInit(this.constructor);
+            }
+        },
+        compare(c) {
+            if (this.detected && this.constructor) {
+                return (this.constructor === c ||
+                    c instanceof this.constructor ||
+                    c.prototype instanceof this.constructor);
+            }
+            return false;
+        },
+    };
+}
+
+const PLUGIN_NAME = 'moost-vite-dev';
+function gatherAllImporters(moduleNode, visited = new Set()) {
+    if (!moduleNode) {
+        return visited;
+    }
+    if (visited.has(moduleNode)) {
+        return visited;
+    }
+    visited.add(moduleNode);
+    if (moduleNode.importers) {
+        for (const importer of moduleNode.importers) {
+            gatherAllImporters(importer, visited);
+        }
+    }
+    return visited;
+}
+const logger = new EventLogger('', { level: 99 }).createTopic(PLUGIN_NAME);
+function getLogger() {
+    return logger;
+}
+
+function moostRestartCleanup(adapters, cleanupInstances) {
+    const logger = getLogger();
+    const infact = getMoostInfact();
+    const { registry } = infact;
+    infact._cleanup();
+    const mate = getMoostMate();
+    if (cleanupInstances) {
+        for (const key of Object.getOwnPropertySymbols(registry)) {
+            const instance = registry[key];
+            const viteId = mate.read(instance)?.__vite_id;
+            if (viteId && cleanupInstances.has(viteId)) {
+                logger.debug(`🔃 Replacing "${constructorName(instance)}"`);
+                delete registry[key];
+            }
+        }
+        for (const key of Object.getOwnPropertySymbols(registry)) {
+            const instance = registry[key];
+            scanParams(instance, (type) => {
+                if (type === Moost || type instanceof Moost || type.prototype instanceof Moost) {
+                    delete registry[key];
+                    logger.debug(`✖️  Ejecting "${constructorName(instance)}" (depends on re-instantiated "Moost")`);
+                    return true;
+                }
+                for (const adapter of adapters) {
+                    if (adapter.compare(type)) {
+                        delete registry[key];
+                        logger.debug(`✖️  Ejecting "${constructorName(instance)}" (depends on re-instantiated "${adapter.constructor.name}")`);
+                        return true;
+                    }
+                }
+            });
+        }
+        clearDependantRegistry(registry);
+        infact.registry = registry;
+    }
+    getMoostMate()._cleanup();
+    getGlobalWooks(undefined, undefined, 'cleanup');
+}
+function clearDependantRegistry(registry) {
+    const logger = getLogger();
+    const objSet = new Set();
+    let somethingIsDeleted = true;
+    while (somethingIsDeleted) {
+        somethingIsDeleted = false;
+        for (const key of Object.getOwnPropertySymbols(registry)) {
+            const instance = registry[key];
+            objSet.add(Object.getPrototypeOf(instance).constructor);
+        }
+        for (const key of Object.getOwnPropertySymbols(registry)) {
+            const instance = registry[key];
+            scanParams(instance, (type) => {
+                if (!objSet.has(type)) {
+                    delete registry[key];
+                    logger.debug(`✖️  Ejecting "${constructorName(instance)}" (depends on "${type.name}" which is not in registry)`);
+                    somethingIsDeleted = true;
+                    return true;
+                }
+            });
+        }
+    }
+}
+function scanParams(instance, cb) {
+    const mate = getMoostMate();
+    const params = mate.read(instance)?.params;
+    if (params?.length) {
+        for (const param of params) {
+            if (param.type === undefined ||
+                [Array, String, Number, Boolean].includes(param.type)) {
+                continue;
+            }
+            if (cb(param.type)) {
+                break;
+            }
+        }
+    }
+}
+function constructorName(i) {
+    return Object.getPrototypeOf(i).constructor.name;
+}
+
+const REG_HAS_EXPORT_CLASS = /(^\s*@(Injectable|Controller)\()/m;
+const REG_REPLACE_EXPORT_CLASS = /(^\s*@(Injectable|Controller)\()/gm;
+function moostViteDev(options) {
+    const entry = options.entry;
+    let moostMiddleware = null;
+    const adapters = [
+        createAdapterDetector('http', MoostHttp => {
+            MoostHttp.prototype.listen = function (...args) {
+                moostMiddleware = this.getServerCb();
+                setTimeout(() => {
+                    args.filter(a => typeof a === 'function').forEach(a => a());
+                }, 1);
+                return Promise.resolve();
+            };
+        }),
+        createAdapterDetector('cli'),
+        createAdapterDetector('wf'),
+    ];
+    const logger = getLogger();
+    let reloadRequired = false;
+    return {
+        name: PLUGIN_NAME,
+        apply: 'serve',
+        enforce: 'pre',
+        config(cfg) {
+            return {
+                server: {
+                    port: cfg.server?.port || options.port || 3000,
+                    host: cfg.server?.host || options.host,
+                },
+                optimizeDeps: {
+                    noDiscovery: cfg.optimizeDeps?.noDiscovery === undefined ? true : cfg.optimizeDeps.noDiscovery,
+                    exclude: cfg.optimizeDeps?.exclude || ['@swc/core'],
+                },
+                build: {
+                    target: cfg.build?.target || 'node20',
+                    outDir: cfg.build?.outDir || options.outDir || 'dist',
+                    ssr: cfg.build?.ssr || options.entry,
+                    minify: cfg.build?.minify || false,
+                    rollupOptions: {
+                        input: cfg.build?.rollupOptions?.input || options.entry,
+                        output: cfg.build?.rollupOptions?.output || {
+                            format: options.format,
+                            sourcemap: !!(options.sourcemap ?? true),
+                        },
+                    },
+                },
+            };
+        },
+        async transform(code, id) {
+            if (!id.endsWith('.ts')) {
+                return code;
+            }
+            for (const adapter of adapters) {
+                if (!adapter.detected && adapter.regex.test(code)) {
+                    await adapter.init();
+                }
+            }
+            if (REG_HAS_EXPORT_CLASS.test(code)) {
+                code = code.replace(REG_REPLACE_EXPORT_CLASS, '\n@__VITE_ID(import.meta.filename)\n$1');
+                code = `import { __VITE_ID } from 'virtual:vite-id'\n\n${code}`;
+            }
+            return code;
+        },
+        resolveId(id) {
+            if (id === 'virtual:vite-id') {
+                return '\0virtual:vite-id';
+            }
+        },
+        load(id) {
+            if (id === '\0virtual:vite-id') {
+                return `
+          import { getMoostMate } from "moost";
+          const mate = getMoostMate();
+          export function __VITE_ID(id) {
+            return mate.decorate("__vite_id", id)
+          }
+        `;
+            }
+        },
+        async configureServer(server) {
+            moostRestartCleanup(adapters);
+            await server.ssrLoadModule(entry);
+            server.middlewares.use(async (req, res, next) => {
+                if (reloadRequired) {
+                    console.clear();
+                    reloadRequired = false;
+                    logger.debug('🚀 Reloading Moost App...');
+                    await server.ssrLoadModule(entry);
+                    await new Promise(resolve => setTimeout(resolve, 1));
+                }
+                if (moostMiddleware) {
+                    return moostMiddleware(req, res);
+                }
+                next();
+            });
+        },
+        hotUpdate({ file }) {
+            if (file.endsWith('.ts')) {
+                const modules = this.environment.moduleGraph.getModulesByFile(file);
+                if (modules) {
+                    logger.debug(`🔃 Hot update: ${file}`);
+                    const cleanupInstances = new Set();
+                    for (const mod of modules) {
+                        const allImporters = gatherAllImporters(mod);
+                        for (const impModule of allImporters) {
+                            if (impModule.id) {
+                                cleanupInstances.add(impModule.id);
+                            }
+                        }
+                        this.environment.moduleGraph.invalidateModule(mod);
+                    }
+                    moostMiddleware = null;
+                    moostRestartCleanup(adapters, cleanupInstances);
+                    reloadRequired = true;
+                }
+                return [];
+            }
+        },
+    };
+}
+
+export { moostViteDev };

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@moostjs/vite",
+  "version": "0.4.23",
+  "description": "Vite Dev plugin for moostjs",
+  "main": "dist/index.cjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/moostjs/moostjs.git",
+    "directory": "packages/vite"
+  },
+  "keywords": [
+    "moost",
+    "moostjs",
+    "composables",
+    "framework",
+    "wooksjs",
+    "prostojs",
+    "vite"
+  ],
+  "author": "Artem Maltsev",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/moostjs/moostjs/issues"
+  },
+  "homepage": "https://github.com/moostjs/moostjs/tree/main/packages/vite#readme",
+  "peerDependencies": {
+    "moost": "0.4.23",
+    "@moostjs/event-http": "0.4.23",
+    "vite": "6.x"
+  }
+}