@jitar/plugin-vite 0.7.6 → 0.8.1

package/dist/index.d.ts

@@ -1,2 +1,11 @@
 import { PluginOption } from 'vite';
-export default function viteJitar(sourcePath: string, jitarPath: string, jitarUrl: string, segments?: string[], middlewares?: string[]): PluginOption;
+type PluginConfig = {
+    sourceDir: string;
+    targetDir: string;
+    jitarDir: string;
+    jitarUrl: string;
+    segments?: string[];
+    middleware?: string[];
+};
+export type { PluginConfig as JitarConfig };
+export default function viteJitar(pluginConfig: PluginConfig): PluginOption;

package/dist/index.js

@@ -1,86 +1,150 @@
+import fs from 'fs';
 import path from 'path';
 import { normalizePath } from 'vite';
-import { Reflector, ReflectionFunction } from '@jitar/reflection';
-const reflector = new Reflector();
-function formatPath(path) {
-    path = normalizePath(path);
-    if (path.startsWith('/')) {
-        path = path.substring(1);
+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 (path.endsWith('/')) {
-        path = path.substring(0, path.length - 1);
+    if (dir.endsWith('/')) {
+        dir = dir.substring(0, dir.length - 1);
     }
-    return path;
+    return dir;
 }
-function createServerConfig(jitarUrl) {
-    return {
-        build: {
-            target: 'esnext'
-        },
-        server: {
-            proxy: {
-                '/rpc': jitarUrl,
-                '/jitar': jitarUrl,
-                '/modules': jitarUrl,
-            }
-        }
-    };
-}
-function createBootstrapCode(segments, middlewares) {
-    const segmentString = segments.map(segment => `'${segment}'`).join(', ');
-    const middlewareString = middlewares.map(middleware => `'${middleware}'`).join(', ');
-    return `<script type="module">const jitar = await import("/jitar/client.js"); await jitar.startClient(document.location.origin, [${segmentString}], [${middlewareString}]);</script>`;
-}
-async function createImportCode(code, id, jitarFullPath, jitarPath) {
-    const relativeId = id
-        .replace(jitarFullPath, '')
-        .replace('.ts', '.js');
-    const module = reflector.parse(code);
-    const exported = module.exported;
-    const allKeys = [...exported.keys()];
-    const functionKeys = allKeys.filter(key => key !== 'default' && exported.get(key) instanceof ReflectionFunction);
-    let importCode = '';
-    let exportCode = '';
-    if (exported.has('default')) {
-        importCode += `const defaultExport = module.default;\n`;
-        exportCode += `export default defaultExport;\n`;
+function assureExtension(filename) {
+    if (filename.endsWith('.js')) {
+        return filename;
     }
-    if (functionKeys.length > 0) {
-        importCode += functionKeys.map(key => `const ${key} = module.${key};`).join('\n');
-        exportCode += `export { ${functionKeys.join(', ')} };\n`;
-    }
-    return 'import { getClient } from "/jitar/client.js";\n'
-        + `const module = await (await getClient()).import("./${jitarPath}${relativeId}");\n`
-        + importCode
-        + exportCode;
+    return `${filename}.js`;
+}
+function makeShared(filename) {
+    return assureExtension(filename).replace('.js', '.shared.js');
 }
-export default function viteJitar(sourcePath, jitarPath, jitarUrl, segments = [], middlewares = []) {
-    sourcePath = formatPath(sourcePath);
-    jitarPath = formatPath(jitarPath);
-    let jitarFullPath = undefined;
+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 = ['shared', ...segments, 'remote'];
+    let rootPath;
+    let sourcePath;
+    let targetPath;
+    let outputPath;
+    let jitarPath;
+    let jitarBundleFilename;
+    let jitarBundleImported = false;
     return {
         name: 'jitar-plugin-vite',
-        enforce: 'post',
         config() {
-            return createServerConfig(jitarUrl);
+            return {
+                build: { target: 'esnext' },
+                server: { proxy: { '/rpc': jitarUrl } }
+            };
         },
         configResolved(resolvedConfig) {
-            jitarFullPath = path.join(resolvedConfig.root, sourcePath, jitarPath);
+            rootPath = path.join(resolvedConfig.root);
+            sourcePath = path.join(rootPath, sourceDir);
+            targetPath = path.join(rootPath, targetDir);
+            outputPath = path.join(targetPath, resolvedConfig.build.assetsDir);
+            jitarPath = path.join(sourcePath, jitarDir);
         },
-        resolveId(source) {
-            if (source === '/jitar/client.js') {
-                return { id: source, external: 'absolute' };
+        options(options) {
+            if (options.input === undefined) {
+                options.input = JITAR_BUNDLE_ID;
+            }
+            else if (typeof options.input === 'string') {
+                options.input = [options.input, JITAR_BUNDLE_ID];
+            }
+            else if (Array.isArray(options.input)) {
+                options.input.push(JITAR_BUNDLE_ID);
+            }
+            else if (typeof options.input === 'object') {
+                options.input.additionalEntry = JITAR_BUNDLE_ID;
+            }
+            return options;
+        },
+        resolveId: {
+            order: 'pre',
+            async handler(source, importer, options) {
+                if (source === JITAR_BUNDLE_ID) {
+                    return source;
+                }
+                if (source === JITAR_SOURCE_ID) {
+                    if (importer?.endsWith('.segment.js') === false) {
+                        jitarBundleImported = true;
+                    }
+                    return JITAR_BUNDLE_ID;
+                }
+                const resolution = await this.resolve(source, importer, options);
+                if (resolution === null || jitarPath === undefined || resolution.id.includes(jitarPath) === false) {
+                    return null;
+                }
+                const cacheId = resolution.id.replace(`/${sourceDir}/`, `/${targetDir}/`);
+                for (const scope of scopes) {
+                    const scopeId = cacheId.replace('.ts', `.${scope}.js`);
+                    if (fs.existsSync(scopeId)) {
+                        return scopeId;
+                    }
+                }
+                return resolution.id;
             }
-            return null;
         },
-        async transform(code, id) {
-            if (jitarFullPath === undefined || id.includes(jitarFullPath) === false) {
-                return code;
+        load(id) {
+            if (id !== JITAR_BUNDLE_ID) {
+                return null;
+            }
+            const segmentFiles = segments.map(name => `${targetPath}/${name}.segment.js`);
+            const middlewareFiles = middlewares.map(name => makeShared(`${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 = 'clientBuilder.build({remoteUrl, segments, middleware});';
+            const client = [remoteBuilder, clientBuilder, build].join('\n');
+            const exports = `export * from "${JITAR_CLIENT_ID}";`;
+            return [imports, declarations, client, exports].join('\n');
+        },
+        generateBundle(options, bundle) {
+            const bundles = Object.entries(bundle);
+            for (const [fileName, chunk] of bundles) {
+                if (chunk.type === 'chunk' && chunk.name === JITAR_BUNDLE_ID) {
+                    jitarBundleFilename = fileName;
+                    break;
+                }
             }
-            return createImportCode(code, id, jitarFullPath, jitarPath);
         },
         transformIndexHtml(html) {
-            return html.replace('<head>', `<head>${createBootstrapCode(segments, middlewares)}`);
+            if (jitarBundleImported === true) {
+                return html;
+            }
+            if (jitarBundleFilename === undefined) {
+                if (outputPath === undefined) {
+                    console.warn('Output path not found!');
+                    return html;
+                }
+                const filenames = fs.readdirSync(outputPath);
+                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');
+                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.7.6",
+  "version": "0.8.1",
   "description": "Vite plugin for Jitar.",
   "author": "Masking Technology <info@masking.tech> (https://jitar.dev)",
   "license": "MIT",
@@ -26,9 +26,6 @@
   "publishConfig": {
     "access": "public"
   },
-  "dependencies": {
-    "@jitar/reflection": "^0.7.6"
-  },
   "peerDependencies": {
     "vite": ">=4.0.0 || >=5.0.0"
   },
@@ -50,5 +47,5 @@
     "vite-plugin",
     "jitar"
   ],
-  "gitHead": "0a9289db7787cfafdcc9a198b87cadb8843a3d75"
+  "gitHead": "cb82f7e31ef4015e0d569a70f1e990859dc0f870"
 }