@vorplex/compiler 0.0.63 → 0.0.65

package/dist/compiler.util.js

@@ -29,11 +29,14 @@ export class Compiler {
         const task = options.task ?? new Task('Compile');
         try {
             task.log(`Compiling $[files] using entry file path (${options.entryFilePath})`, { attachments: { files: { type: 'yaml', value: stringify(options.files) } } });
+            const importOrigin = {};
             return await Bundler.bundle({
                 path: options.entryFilePath,
                 script: options.files[options.entryFilePath].content,
                 sourcemaps: options.sourcemaps,
-                resolve: async ({ importerPath, importPath, importStack }) => {
+                resolve: async ({ importerPath, importPath }) => {
+                    const origin = importerPath in options.files ? importerPath : importOrigin[importerPath] ?? importerPath;
+                    importOrigin[importPath] ??= origin;
                     return await task.do(`Resolving: ${importPath}`, async (task) => {
                         if (importPath in options.files) {
                             task.log('Returning local file $[content]', { attachments: { content: { type: 'typescript', value: options.files[importPath].content } } });
@@ -66,7 +69,7 @@ export class Compiler {
                             }
                         }
                         try {
-                            const dependencyTree = options.files[importStack.find(importPath => options.files[importPath]?.dependencyTree)]?.dependencyTree ?? options.files[importPath].dependencyTree ?? {};
+                            const dependencyTree = options.files[origin]?.dependencyTree ?? options.files[importPath]?.dependencyTree ?? {};
                             const string = NPM.parseImportString(importPath);
                             task.log(`Package ${string.packageName} subpath ${string.subpath} version ${string.version}`);
                             if (!string.version) {

package/dist/module-loader/bundler.d.ts

@@ -9,7 +9,6 @@ export declare class Bundler {
             importerPath: string;
             importPath: string;
             relative: boolean;
-            importStack: string[];
         }) => Promise<{
             namespace: string;
         } | {

package/dist/module-loader/bundler.js

@@ -32,44 +32,34 @@ export class Bundler {
                     name: 'module-loader-resolver',
                     setup: (build) => {
                         const files = {};
-                        const importParent = {};
-                        const importPathAlias = {};
                         build.onResolve({ filter: /.*/ }, async (args) => {
                             const relative = args.path.startsWith('.') || args.path.startsWith('/');
                             const importerPath = args.importer === '<stdin>' ? options.path : args.importer;
                             const importPath = relative ? $Path.join(importerPath, `../${args.path}`) : args.path;
-                            importParent[importPath] ??= importerPath;
-                            let importStack = [];
-                            const visited = new Set();
-                            let parentPath = importerPath;
-                            while (parentPath && !visited.has(parentPath)) {
-                                visited.add(parentPath);
-                                importStack.push(parentPath);
-                                parentPath = importParent[importPathAlias[parentPath]] ?? importParent[parentPath];
-                            }
                             const resolved = await options.resolve({
                                 namespace: args.path,
                                 importerPath,
                                 importPath,
                                 relative,
-                                importStack
                             });
-                            if (!resolved)
-                                return { path: importPath, namespace: 'mock' };
-                            if ('content' in resolved) {
-                                files[resolved.path ?? importPath] = resolved.content;
-                                if (resolved.path)
-                                    importPathAlias[resolved.path] = importPath;
+                            if (!resolved) {
                                 return {
-                                    path: resolved.path ?? importPath,
-                                    namespace: 'virtual',
+                                    path: importPath,
+                                    namespace: 'mock',
                                 };
                             }
-                            else
+                            if ('content' in resolved) {
+                                const resolvedPath = resolved.path ?? importPath;
+                                files[resolvedPath] = resolved.content;
                                 return {
-                                    path: resolved.namespace,
-                                    external: true,
+                                    path: resolvedPath,
+                                    namespace: 'virtual',
                                 };
+                            }
+                            return {
+                                path: resolved.namespace,
+                                external: true,
+                            };
                         });
                         build.onLoad({ filter: /.*/, namespace: 'virtual' }, (args) => {
                             const loaders = {
@@ -93,8 +83,8 @@ export class Bundler {
                 },
             ],
             sourcemap: options.sourcemaps ? 'inline' : false,
-            mainFields: ['module', 'main'],
-            conditions: ['import', 'module'],
+            mainFields: ['browser', 'module', 'main'],
+            conditions: ['browser', 'import', 'module'],
             bundle: true,
             format: 'cjs',
             target: 'esnext',

package/dist/npm/jsdelivr/jsdelivr.util.js

@@ -1,4 +1,5 @@
 import { $Path, $String, InMemoryStorage } from '@vorplex/core';
+import { NPM } from '../npm.util';
 export class JsDelivr {
     static url = 'https://cdn.jsdelivr.net/npm';
     static dataUrl = 'https://data.jsdelivr.com/v1/packages/npm';
@@ -123,67 +124,11 @@ export class JsDelivr {
         if (cached)
             return cached;
         const packageJson = await this.getPackageJson(packageName, version);
-        if (packageJson.exports) {
-            const resolveExports = async (exports) => {
-                const result = {};
-                if (typeof exports === 'string')
-                    return { '.': $Path.relative(exports) };
-                const resolveExportPath = (path) => {
-                    if (!path)
-                        return;
-                    if (typeof path === 'string')
-                        return path;
-                    if (typeof path !== 'object')
-                        return;
-                    const priorities = ['browser', 'import', 'es2015', 'module', 'default', 'node', 'require'];
-                    for (const priority of priorities) {
-                        const resolvedPath = resolveExportPath(path[priority]);
-                        if (resolvedPath)
-                            return resolvedPath;
-                    }
-                };
-                for (const [path, value] of Object.entries(exports)) {
-                    let targetPath = resolveExportPath(value);
-                    if (!targetPath || targetPath === './')
-                        continue;
-                    if (targetPath.startsWith('./'))
-                        targetPath = targetPath.slice(2);
-                    if ($Path.getExtension(targetPath) === '.cjs')
-                        continue;
-                    if (targetPath.includes('*')) {
-                        const regex = new RegExp(`^${$String.sanitizeForRegex(targetPath).replace('\\*', '(.+)')}$`);
-                        const files = await this.getFilePaths(packageName, semanticVersion, regex);
-                        for (const file of files) {
-                            const fileExtension = $Path.getExtension(file);
-                            if (!['.js', '.mjs', '.json', '.jsx'].includes(fileExtension))
-                                continue;
-                            const wildcard = file.match(regex)[1];
-                            const resolvedPath = path.replaceAll('*', wildcard);
-                            const resolvedTargetPath = targetPath.replaceAll('*', wildcard);
-                            if (Object.values(result).includes($Path.relative(resolvedTargetPath)))
-                                continue;
-                            result[resolvedPath] = $Path.relative(resolvedTargetPath);
-                        }
-                    }
-                    else {
-                        if (Object.values(result).includes($Path.relative(targetPath)))
-                            continue;
-                        result[path] = $Path.relative(targetPath);
-                    }
-                }
-                return result;
-            };
-            const exports = await resolveExports(packageJson.exports);
-            if (!subpath && exports['.']) {
-                const result = $Path.absolute(exports['.']);
-                await this.cache.set('cache', 'file-path', key, result);
-                return result;
-            }
-            if (subpath && exports[$Path.relative(subpath)]) {
-                const result = $Path.absolute(exports[$Path.relative(subpath)]);
-                await this.cache.set('cache', 'file-path', key, result);
-                return result;
-            }
+        const filePaths = await this.getFilePaths(packageName, version);
+        const entryPoint = NPM.getPackageEntryPoint(packageJson, filePaths, subpath);
+        if (entryPoint) {
+            await this.cache.set('cache', 'file-path', key, entryPoint);
+            return entryPoint;
         }
         if (subpath) {
             const file = await this.resolveFilePath(packageName, version, subpath);
@@ -192,11 +137,6 @@ export class JsDelivr {
                 return file;
             }
         }
-        else {
-            const result = $Path.absolute(packageJson.module || packageJson.main || 'index.js');
-            await this.cache.set('cache', 'file-path', key, result);
-            return result;
-        }
         throw new Error(`Failed to resolve file path for import (${packageName}${subpath ? `/${subpath}` : ''}@${semanticVersion})`);
     }
 }

package/dist/npm/npm.util.d.ts

@@ -15,6 +15,7 @@ export declare class NPM {
     }, task?: Task): Promise<DependencyTree>;
     static flattenDependencyTree(tree: DependencyTree): Record<string, string[]>;
     static resolveDependencyVersion(tree: DependencyTree, parent: string, version: string, name: string): string;
+    static getPackageEntryPoint(packageJson: PackageJson, filePaths: string[], subpath?: string): string | null;
     static getScriptImports(script: string): string[];
     static parseImportString(string: string): {
         packageName: string;

package/dist/npm/npm.util.js

@@ -1,4 +1,4 @@
-import { $Path, Task } from '@vorplex/core';
+import { $Path, $String, Task } from '@vorplex/core';
 import { satisfies } from 'semver';
 import { stringify } from 'yaml';
 export class NPM {
@@ -106,6 +106,75 @@ export class NPM {
         };
         return resolve(tree);
     }
+    static getPackageEntryPoint(packageJson, filePaths, subpath) {
+        if (packageJson.exports) {
+            const resolveExports = (exports) => {
+                const result = {};
+                if (typeof exports === 'string')
+                    return { '.': $Path.relative(exports) };
+                const resolveExportPath = (path) => {
+                    if (!path)
+                        return;
+                    if (typeof path === 'string')
+                        return path;
+                    if (typeof path !== 'object')
+                        return;
+                    for (const priority of ['browser', 'import', 'es2015', 'module', 'default', 'node', 'require']) {
+                        const resolvedPath = resolveExportPath(path[priority]);
+                        if (resolvedPath)
+                            return resolvedPath;
+                    }
+                };
+                for (const [path, value] of Object.entries(exports)) {
+                    let targetPath = resolveExportPath(value);
+                    if (!targetPath || targetPath === './')
+                        continue;
+                    if (targetPath.startsWith('./'))
+                        targetPath = targetPath.slice(2);
+                    if ($Path.getExtension(targetPath) === '.cjs')
+                        continue;
+                    if (targetPath.includes('*')) {
+                        const regex = new RegExp(`^${$String.sanitizeForRegex(targetPath).replace('\\*', '(.+)')}$`);
+                        for (const path of filePaths.filter(path => regex.test(path))) {
+                            const extension = $Path.getExtension(path);
+                            if (!['.js', '.mjs', '.json', '.jsx'].includes(extension))
+                                continue;
+                            const wildcard = path.match(regex)[1];
+                            const resolvedPath = path.replaceAll('*', wildcard);
+                            const resolvedTargetPath = targetPath.replaceAll('*', wildcard);
+                            if (Object.values(result).includes($Path.relative(resolvedTargetPath)))
+                                continue;
+                            result[resolvedPath] = $Path.relative(resolvedTargetPath);
+                        }
+                    }
+                    else {
+                        if (Object.values(result).includes($Path.relative(targetPath)))
+                            continue;
+                        result[path] = $Path.relative(targetPath);
+                    }
+                }
+                return result;
+            };
+            const exports = resolveExports(packageJson.exports);
+            if (!subpath && exports['.'])
+                return $Path.absolute(exports['.']);
+            if (subpath && exports[$Path.relative(subpath)])
+                return $Path.absolute(exports[$Path.relative(subpath)]);
+        }
+        if (!subpath) {
+            let entryPoint = $Path.absolute(packageJson.module || packageJson.main || 'index.js');
+            if (typeof packageJson.browser === 'string') {
+                entryPoint = $Path.absolute(packageJson.browser);
+            }
+            else if (packageJson.browser != null && typeof packageJson.browser === 'object') {
+                const remapped = Object.entries(packageJson.browser).find(([key]) => $Path.absolute(key) === entryPoint)?.[1];
+                if (typeof remapped === 'string')
+                    entryPoint = $Path.absolute(remapped);
+            }
+            return entryPoint;
+        }
+        return null;
+    }
     static getScriptImports(script) {
         return Array.from(script.matchAll(/import\s+[\s\S]*?\s+from\s+['"]([^'"]+)['"]|require\(['"]([^'"]+)['"]\)/g)).map((match) => match[1] ?? match[2]);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vorplex/compiler",
-  "version": "0.0.63",
+  "version": "0.0.65",
   "type": "module",
   "sideEffects": false,
   "files": [
@@ -15,16 +15,16 @@
   "types": "./dist/index.d.ts",
   "main": "./dist/index.js",
   "dependencies": {
-    "@vorplex/core": "0.0.63",
     "esbuild-wasm": "0.25.12",
-    "tslib": "2.8.1",
     "semver": "7.7.3",
+    "tslib": "2.8.1",
+    "@vorplex/core": "0.0.65",
     "typescript": "5.9.3",
     "yaml": "2.8.2"
   },
   "devDependencies": {
-    "@types/semver": "7.7.1",
-    "vitest": "3.2.4"
+    "vitest": "3.2.4",
+    "@types/semver": "7.7.1"
   },
   "scripts": {
     "build": "tsc -b --force tsconfig.build.json",