@vorplex/compiler 0.0.15 → 0.0.21

package/dist/index.d.ts

@@ -1,7 +1,7 @@
 export * from './compiler.util';
-export * from './script-analyzer.util';
 export * from './module-loader/bundler';
 export * from './module-loader/module-loader.util';
+export * from './npm/jsdelivr/jsdelivr.util';
 export * from './npm/npm.util';
 export * from './npm/package-json.type';
-export * from './npm/jsdelivr/jsdelivr.util';
+export * from './script-analyzer.util';

package/dist/index.js

@@ -1,8 +1,8 @@
 // **/*.ts
 export * from './compiler.util';
-export * from './script-analyzer.util';
 export * from './module-loader/bundler';
 export * from './module-loader/module-loader.util';
+export * from './npm/jsdelivr/jsdelivr.util';
 export * from './npm/npm.util';
 export * from './npm/package-json.type';
-export * from './npm/jsdelivr/jsdelivr.util';
+export * from './script-analyzer.util';

package/dist/module-loader/bundler.js

@@ -38,7 +38,7 @@ export class Bundler {
                             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;
+                            importParent[importPath] ??= importerPath;
                             let importStack = [];
                             let parentPath = importerPath;
                             while (parentPath) {

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

@@ -1,3 +1,4 @@
+import { type StorageProvider } from '@vorplex/core';
 import type { PackageJson } from '../package-json.type';
 export interface JsDelivrData {
     name: string;
@@ -10,23 +11,33 @@ export interface JsDelivrFileEntry {
     name: string;
     files: JsDelivrFileEntry[];
 }
+export interface PackageFile {
+    packageName: string;
+    packageVersion: string;
+    url: string;
+    path?: string;
+    content: string;
+}
+export declare const JsDelivrCacheStore: {
+    readonly PackageVersion: "package-version";
+    readonly Data: "data";
+    readonly PackageJson: "package-json";
+    readonly FilePath: "file-path";
+    readonly File: "file";
+    readonly ImportFilePath: "import-filePath";
+};
+export type JsDelivrCacheStore = typeof JsDelivrCacheStore[keyof typeof JsDelivrCacheStore];
 export declare class JsDelivr {
     static readonly url: "https://cdn.jsdelivr.net/npm";
     static readonly dataUrl: "https://data.jsdelivr.com/v1/packages/npm";
     static readonly resolveUrl: "https://data.jsdelivr.com/v1/package/resolve/npm";
-    static packageVersionCache: Record<string, Record<string, string>>;
+    static cache: StorageProvider<'js-delivr', JsDelivrCacheStore>;
     static resolveVersion(name: string, semanticVersion?: string): Promise<string>;
     static getPackageVersions(name: string): Promise<string[]>;
     static getData(name: string, semanticVersion: string): Promise<JsDelivrData>;
     static getFilePaths(name: string, semanticVersion: string, regex?: RegExp): Promise<string[]>;
     static resolveFilePath(name: string, semanticVersion: string, path: string): Promise<string>;
-    static getFile(name: string, semanticVersion: string, path?: string): Promise<{
-        packageName: string;
-        packageVersion: string;
-        url: string;
-        path?: string;
-        content: string;
-    }>;
+    static getFile(name: string, semanticVersion: string, path?: string): Promise<PackageFile>;
     static getPackageJson(name: string, semanticVersion: string): Promise<PackageJson>;
     static parseUrl(url: string): {
         name: string;

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

@@ -1,19 +1,29 @@
-import { $Path, $String } from '@vorplex/core';
+import { $Path, $String, InMemoryStorage } from '@vorplex/core';
+export const JsDelivrCacheStore = {
+    PackageVersion: 'package-version',
+    Data: 'data',
+    PackageJson: 'package-json',
+    FilePath: 'file-path',
+    File: 'file',
+    ImportFilePath: 'import-filePath'
+};
 export class JsDelivr {
     static url = 'https://cdn.jsdelivr.net/npm';
     static dataUrl = 'https://data.jsdelivr.com/v1/packages/npm';
     static resolveUrl = 'https://data.jsdelivr.com/v1/package/resolve/npm';
-    static packageVersionCache = {};
+    static cache = new InMemoryStorage();
     static async resolveVersion(name, semanticVersion) {
         semanticVersion ??= 'latest';
-        if (this.packageVersionCache[name]?.[semanticVersion])
-            return this.packageVersionCache[name][semanticVersion];
+        const key = `${name}@${semanticVersion}`;
+        const cached = await this.cache.get('js-delivr', JsDelivrCacheStore.PackageVersion, key);
+        if (cached)
+            return cached;
         const url = $Path.join(this.resolveUrl, `${name}@${semanticVersion}`);
         const response = await fetch(url);
         if (!response.ok)
             throw new Error(`Failed to fetch package (${name}) version (${semanticVersion}). ${response.statusText}`);
         const data = (await response.json());
-        this.packageVersionCache[name] = Object.assign({}, this.packageVersionCache[name], { [semanticVersion]: data.version });
+        await this.cache.set('js-delivr', JsDelivrCacheStore.PackageVersion, key, data.version);
         return data.version;
     }
     static async getPackageVersions(name) {
@@ -26,11 +36,17 @@ export class JsDelivr {
     }
     static async getData(name, semanticVersion) {
         const version = await this.resolveVersion(name, semanticVersion);
+        const key = `${name}@${version}`;
+        const cached = await this.cache.get('js-delivr', JsDelivrCacheStore.Data, key);
+        if (cached)
+            return cached;
         const url = $Path.join(this.dataUrl, `${name}@${version}`);
         const response = await fetch(url);
         if (!response.ok)
             throw new Error(`Failed to fetch package (${name}) metadata. ${response.statusText}`);
-        return await response.json();
+        const data = await response.json();
+        await this.cache.set('js-delivr', JsDelivrCacheStore.Data, key, data);
+        return data;
     }
     static async getFilePaths(name, semanticVersion, regex) {
         const version = await this.resolveVersion(name, semanticVersion);
@@ -40,7 +56,8 @@ export class JsDelivr {
             for (const entry of target.files) {
                 const entryPath = $Path.join(path, entry.name);
                 if (entry.type === 'directory')
-                    files.push(...getFiles(entry, entryPath));
+                    for (const file of getFiles(entry, entryPath))
+                        files.push(file);
                 else if (entryPath.match(regex))
                     files.push(entryPath);
             }
@@ -49,7 +66,12 @@ export class JsDelivr {
         return getFiles(metadata, '/');
     }
     static async resolveFilePath(name, semanticVersion, path) {
-        const paths = await this.getFilePaths(name, semanticVersion, new RegExp('^' + $String.sanitizeForRegex($Path.absolute(path)) + '(?:\\.js|/index.js)?$'));
+        const version = await this.resolveVersion(name, semanticVersion);
+        const key = `${name}@${version}:${path}`;
+        const cached = await this.cache.get('js-delivr', JsDelivrCacheStore.FilePath, key);
+        if (cached)
+            return cached;
+        const paths = await this.getFilePaths(name, version, new RegExp('^' + $String.sanitizeForRegex($Path.absolute(path)) + '(?:\\.js|/index.js)?$'));
         function getPathPriority(filePath) {
             if (filePath === path)
                 return 4;
@@ -59,34 +81,56 @@ export class JsDelivr {
                 return 2;
             return 1;
         }
-        return paths.sort((a, b) => getPathPriority(b) - getPathPriority(a))[0];
+        const resolved = paths.sort((a, b) => getPathPriority(b) - getPathPriority(a))[0];
+        if (resolved)
+            await this.cache.set('js-delivr', JsDelivrCacheStore.FilePath, key, resolved);
+        return resolved;
     }
     static async getFile(name, semanticVersion, path) {
-        const resolvedPath = path ? await this.resolveFilePath(name, semanticVersion, path) : null;
+        const resolvedVersion = await this.resolveVersion(name, semanticVersion);
+        const resolvedPath = path ? await this.resolveFilePath(name, resolvedVersion, path) : null;
         if (path && !resolvedPath)
             throw new Error(`Failed to resolve path (${path}) from package (${name}) version (${semanticVersion}). Not Found.`);
-        const url = $Path.join(this.url, `${name}@${semanticVersion ?? 'latest'}`, resolvedPath);
+        const key = `${name}@${resolvedVersion}:${resolvedPath ?? ''}`;
+        const cached = await this.cache.get('js-delivr', JsDelivrCacheStore.File, key);
+        if (cached)
+            return cached;
+        const url = $Path.join(this.url, `${name}@${resolvedVersion}`, resolvedPath);
         const response = await fetch(url);
         if (!response.ok)
             throw new Error(`Failed to fetch package (${name}) file (${resolvedPath ?? '<default>'}). ${response.statusText}`);
         const version = response.headers.get('x-jsd-version');
-        return {
+        const file = {
             packageName: name,
             packageVersion: version,
             url: $Path.join(this.url, `${name}@${version}`, resolvedPath),
             path: resolvedPath,
             content: await response.text(),
         };
+        await this.cache.set('js-delivr', JsDelivrCacheStore.File, key, file);
+        return file;
     }
     static async getPackageJson(name, semanticVersion) {
+        const version = await this.resolveVersion(name, semanticVersion);
+        const key = `${name}@${version}`;
+        const cached = await this.cache.get('js-delivr', JsDelivrCacheStore.PackageJson, key);
+        if (cached)
+            return cached;
         const { content } = await this.getFile(name, semanticVersion, 'package.json');
-        return JSON.parse(content);
+        const packageJson = JSON.parse(content);
+        await this.cache.set('js-delivr', JsDelivrCacheStore.PackageJson, key, packageJson);
+        return packageJson;
     }
     static parseUrl(url) {
         return url.match(/https:\/\/cdn\.jsdelivr\.net\/npm\/(?<name>@?[^@]+)@(?<version>[^/]+)(?:\/(?<path>.*))?/)?.groups;
     }
     static async resolveImportFilePath(packageName, semanticVersion, subpath) {
-        const packageJson = await this.getPackageJson(packageName, semanticVersion);
+        const version = await this.resolveVersion(packageName, semanticVersion);
+        const key = `${packageName}@${version}:${subpath ?? ''}`;
+        const cached = await this.cache.get('js-delivr', JsDelivrCacheStore.ImportFilePath, key);
+        if (cached)
+            return cached;
+        const packageJson = await this.getPackageJson(packageName, version);
         if (packageJson.exports) {
             const resolveExports = async (exports) => {
                 const result = {};
@@ -138,18 +182,28 @@ export class JsDelivr {
                 return result;
             };
             const exports = await 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 && exports['.']) {
+                const result = $Path.absolute(exports['.']);
+                await this.cache.set('js-delivr', JsDelivrCacheStore.ImportFilePath, key, result);
+                return result;
+            }
+            if (subpath && exports[$Path.relative(subpath)]) {
+                const result = $Path.absolute(exports[$Path.relative(subpath)]);
+                await this.cache.set('js-delivr', JsDelivrCacheStore.ImportFilePath, key, result);
+                return result;
+            }
         }
         if (subpath) {
-            const file = await this.resolveFilePath(packageName, semanticVersion, subpath);
-            if (file)
+            const file = await this.resolveFilePath(packageName, version, subpath);
+            if (file) {
+                await this.cache.set('js-delivr', JsDelivrCacheStore.ImportFilePath, key, file);
                 return file;
+            }
         }
         else {
-            return $Path.absolute(packageJson.module || packageJson.main || 'index.js');
+            const result = $Path.absolute(packageJson.module || packageJson.main || 'index.js');
+            await this.cache.set('js-delivr', JsDelivrCacheStore.ImportFilePath, key, result);
+            return result;
         }
         throw new Error(`Failed to resolve file path for import (${packageName}${subpath ? `/${subpath}` : ''}@${semanticVersion})`);
     }

package/dist/npm/npm.util.js

@@ -50,31 +50,25 @@ export class NPM {
                 seen[key] = node;
                 if (pkg.dependencies) {
                     task.log('Resolving packages dependencies.');
-                    for (const [depName, depRange] of Object.entries(pkg.dependencies)) {
-                        await task.do(`${depName}@${depRange}`, async (task) => {
-                            node.dependencies[depName] = await resolvePackage(depName, depRange, [node, ...ancestors], task);
-                        });
-                    }
+                    await Promise.all(Object.entries(pkg.dependencies).map(async ([depName, depRange]) => await task.do(`${depName}@${depRange}`, async (task) => {
+                        node.dependencies[depName] = await resolvePackage(depName, depRange, [node, ...ancestors], task);
+                    })));
                     task.log('Done resolving packages dependencies.');
                 }
                 if (pkg.peerDependencies) {
                     task.log('Resolving packages peer-dependencies.');
-                    for (const [peerName, peerRange] of Object.entries(pkg.peerDependencies)) {
-                        await task.do(`${peerName}@${peerRange}`, async (task) => {
-                            node.dependencies[peerName] = await resolvePackage(peerName, peerRange, ancestors, task);
-                        });
-                    }
+                    await Promise.all(Object.entries(pkg.peerDependencies).map(async ([peerName, peerRange]) => await task.do(`${peerName}@${peerRange}`, async (task) => {
+                        node.dependencies[peerName] = await resolvePackage(peerName, peerRange, ancestors, task);
+                    })));
                     task.log('Done resolving packages peer-dependencies.');
                 }
                 return node;
             }
             const tree = {};
             task.log('Resolving packages');
-            for (const [name, range] of Object.entries(packages)) {
-                await task.do(`${name}@${range}`, async (task) => {
-                    tree[name] = await resolvePackage(name, range, [], task);
-                });
-            }
+            await Promise.all(Object.entries(packages).map(async ([name, range]) => await task.do(`${name}@${range}`, async (task) => {
+                tree[name] = await resolvePackage(name, range, [], task);
+            })));
             task.log('Done resolving packages');
             task.log('Done resolving dependency tree');
             return tree;

package/package.json

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