@jitar/plugin-vite 0.10.6 → 0.11.0

package/dist/index.d.ts

@@ -1,8 +1,9 @@
 import { PluginOption } from 'vite';
 type PluginConfig = {
-    sourceDir: string;
-    targetDir: string;
-    jitarDir: string;
+    projectRoot: string;
+    sourceRoot: string;
+    configurationFile?: string;
+    environmentFile?: string;
     jitarUrl: string;
     segments?: string[];
     middleware?: string[];

package/dist/index.js

@@ -1,38 +1,44 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import { ConfigurationManager, BuildHelper } from 'jitar';
 import { normalizePath } from 'vite';
 const JITAR_SOURCE_ID = 'jitar';
 const JITAR_CLIENT_ID = 'jitar/client';
 const JITAR_BUNDLE_ID = 'jitar-bundle';
-function formatDir(dir) {
-    dir = normalizePath(dir);
-    if (dir.startsWith('/')) {
-        dir = dir.substring(1);
-    }
-    if (dir.endsWith('/')) {
-        dir = dir.substring(0, dir.length - 1);
-    }
-    return dir;
-}
 function assureExtension(filename) {
     if (filename.endsWith('.js')) {
         return filename;
     }
     return `${filename}.js`;
 }
+function createJitarBundle(middlewares, targetPath) {
+    const middlewareFiles = middlewares.map(name => assureExtension(`${targetPath}/${name}`));
+    const jitarImport = `import { ClientBuilder, HttpRemoteBuilder } from "${JITAR_CLIENT_ID}";`;
+    const middlewareImports = middlewareFiles.map((filename, index) => `import { default as $M${index} } from "${filename}";`).join('');
+    const imports = [jitarImport, middlewareImports].join('\n');
+    const remoteUrl = 'const remoteUrl = document.location.origin;';
+    const segmentsArray = `const segments = [];`;
+    const middlewareItems = middlewares.map((_, index) => `$M${index}`).join(', ');
+    const middlewareArray = `const middleware = [${middlewareItems}];`;
+    const declarations = [remoteUrl, segmentsArray, middlewareArray].join('\n');
+    const remoteBuilder = 'const remoteBuilder = new HttpRemoteBuilder();';
+    const clientBuilder = 'const clientBuilder = new ClientBuilder(remoteBuilder);';
+    const build = 'const client = clientBuilder.build({remoteUrl, segments, middleware});';
+    const start = 'client.start();';
+    const client = [remoteBuilder, clientBuilder, build, start].join('\n');
+    const exports = `export * from "${JITAR_CLIENT_ID}";`;
+    return [imports, declarations, client, exports].join('\n');
+}
 export default function viteJitar(pluginConfig) {
-    const sourceDir = formatDir(pluginConfig.sourceDir);
-    const targetDir = formatDir(pluginConfig.targetDir);
-    const jitarDir = formatDir(pluginConfig.jitarDir);
     const jitarUrl = pluginConfig.jitarUrl;
     const segments = pluginConfig.segments ?? [];
     const middlewares = pluginConfig.middleware ?? [];
-    const scopes = [...segments, 'remote'];
-    let rootPath;
-    let sourcePath;
-    let targetPath;
-    let outputPath;
-    let jitarPath;
+    const paths = {
+        vite: { input: undefined, output: undefined, assetOutput: undefined },
+        project: { root: undefined, source: undefined },
+        jitar: { input: undefined, output: undefined }
+    };
+    let buildHelper;
     let jitarBundleFilename;
     let jitarBundleImported = false;
     return {
@@ -44,11 +50,22 @@ export default function viteJitar(pluginConfig) {
             };
         },
         configResolved(resolvedConfig) {
-            rootPath = normalizePath(path.join(resolvedConfig.root));
-            sourcePath = normalizePath(path.join(rootPath, sourceDir));
-            targetPath = normalizePath(path.join(rootPath, targetDir));
-            outputPath = normalizePath(path.join(targetPath, resolvedConfig.build.assetsDir));
-            jitarPath = normalizePath(path.join(sourcePath, jitarDir));
+            paths.vite.input = normalizePath(path.join(resolvedConfig.root));
+            paths.vite.output = normalizePath(path.join(paths.vite.input, resolvedConfig.build.outDir));
+            paths.vite.assetOutput = normalizePath(path.join(paths.vite.input, resolvedConfig.build.assetsDir));
+            paths.project.root = normalizePath(path.join(paths.vite.input, pluginConfig.projectRoot));
+            paths.project.source = normalizePath(path.join(paths.vite.input, pluginConfig.sourceRoot));
+        },
+        async buildStart() {
+            const configurationManager = new ConfigurationManager(paths.project.root);
+            if (pluginConfig.environmentFile !== undefined) {
+                await configurationManager.configureEnvironment(pluginConfig.environmentFile);
+            }
+            const configuration = await configurationManager.getRuntimeConfiguration(pluginConfig.configurationFile);
+            paths.jitar.input = normalizePath(path.join(paths.project.root, configuration.source));
+            paths.jitar.output = normalizePath(path.join(paths.project.root, configuration.target));
+            buildHelper = new BuildHelper(configuration);
+            await buildHelper.readApplication();
         },
         options(options) {
             if (options.input === undefined) {
@@ -67,7 +84,7 @@ export default function viteJitar(pluginConfig) {
         },
         resolveId: {
             order: 'pre',
-            async handler(source, importer, options) {
+            async handler(source, importer) {
                 if (source === JITAR_BUNDLE_ID) {
                     return source;
                 }
@@ -77,47 +94,31 @@ export default function viteJitar(pluginConfig) {
                     }
                     return JITAR_BUNDLE_ID;
                 }
-                const resolution = await this.resolve(source, importer, options);
-                if (resolution === null || jitarPath === undefined || resolution.id.includes(jitarPath) === false) {
+            }
+        },
+        load(id) {
+            if (id === JITAR_BUNDLE_ID) {
+                return createJitarBundle(middlewares, paths.vite.output);
+            }
+            if (id.startsWith(paths.project.source)) {
+                if (id.startsWith(paths.vite.input)) {
                     return null;
                 }
-                const cacheId = resolution.id.replace(sourcePath, targetPath);
-                for (const scope of scopes) {
-                    const scopeId = cacheId.replace('.ts', `.${scope}.js`);
-                    if (fs.existsSync(scopeId)) {
-                        return scopeId;
+                const relativeId = id
+                    .replace(paths.project.source, '')
+                    .replace('.ts', '.js');
+                if (relativeId.endsWith('.js')) {
+                    try {
+                        return buildHelper.generateModuleCode(relativeId, segments);
+                    }
+                    catch (error) {
+                        const message = error instanceof Error ? error.message : String(error);
+                        console.error('ERROR:', message);
+                        return null;
                     }
                 }
-                const scopeId = cacheId.replace('.ts', '.js');
-                if (fs.existsSync(scopeId)) {
-                    return scopeId;
-                }
-                return resolution.id;
-            }
-        },
-        load(id) {
-            if (id !== JITAR_BUNDLE_ID) {
-                return null;
             }
-            const segmentFiles = segments.map(name => `${targetPath}/${name}.segment.js`);
-            const middlewareFiles = middlewares.map(name => assureExtension(`${targetPath}/${name}`));
-            const jitarImport = `import { ClientBuilder, HttpRemoteBuilder } from "${JITAR_CLIENT_ID}";`;
-            const segmentImports = segmentFiles.map((filename, index) => `import { default as $S${index} } from "${filename}";`).join('');
-            const middlewareImports = middlewareFiles.map((filename, index) => `import { default as $M${index} } from "${filename}";`).join('');
-            const imports = [jitarImport, segmentImports, middlewareImports].join('\n');
-            const remoteUrl = 'const remoteUrl = document.location.origin;';
-            const segmentsItems = segments.map((_, index) => `$S${index}`).join(', ');
-            const segmentsArray = `const segments = [${segmentsItems}];`;
-            const middlewareItems = middlewares.map((_, index) => `$M${index}`).join(', ');
-            const middlewareArray = `const middleware = [${middlewareItems}];`;
-            const declarations = [remoteUrl, segmentsArray, middlewareArray].join('\n');
-            const remoteBuilder = 'const remoteBuilder = new HttpRemoteBuilder();';
-            const clientBuilder = 'const clientBuilder = new ClientBuilder(remoteBuilder);';
-            const build = 'const client = clientBuilder.build({remoteUrl, segments, middleware});';
-            const start = 'client.start();';
-            const client = [remoteBuilder, clientBuilder, build, start].join('\n');
-            const exports = `export * from "${JITAR_CLIENT_ID}";`;
-            return [imports, declarations, client, exports].join('\n');
+            return null;
         },
         generateBundle(options, bundle) {
             const bundles = Object.entries(bundle);
@@ -133,17 +134,17 @@ export default function viteJitar(pluginConfig) {
                 return html;
             }
             if (jitarBundleFilename === undefined) {
-                if (outputPath === undefined) {
+                if (paths.vite.assetOutput === undefined) {
                     console.warn('Output path not found!');
                     return html;
                 }
-                const filenames = fs.readdirSync(outputPath);
+                const filenames = fs.readdirSync(paths.vite.assetOutput);
                 const jitarFilename = filenames.find(fileName => fileName.startsWith(JITAR_BUNDLE_ID) && fileName.endsWith('.js'));
                 if (jitarFilename === undefined) {
                     console.warn('Jitar bundle not found! Did you build the application first?');
                     return html;
                 }
-                const jitarBundle = fs.readFileSync(path.join(outputPath, jitarFilename), 'utf-8');
+                const jitarBundle = fs.readFileSync(path.join(paths.vite.assetOutput, jitarFilename), 'utf-8');
                 return html.replace('<script', `<script type="module">${jitarBundle}</script>\n    <script`);
             }
             return html.replace('<script', `<script type="module" crossorigin src="/${jitarBundleFilename}"></script>\n    <script`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jitar/plugin-vite",
-  "version": "0.10.6",
+  "version": "0.11.0",
   "description": "Vite plugin for Jitar.",
   "author": "Masking Technology <info@masking.tech> (https://jitar.dev)",
   "license": "MIT",
@@ -31,6 +31,7 @@
     "vite": "^7.3.0"
   },
   "peerDependencies": {
+    "jitar": "^0.11.0",
     "vite": ">=4.0.0 || >=5.0.0 || >=6.0.0 || >=7.0.0"
   },
   "peerDependenciesMeta": {