@nice2dev/game-engine 1.0.5 → 1.0.11

package/dist/esm/unity-integration/UnityAssetStore.js

@@ -0,0 +1,749 @@
+/**
+ * @file UnityAssetStore.ts
+ * @description Unity Asset Store Integration for Nice2Dev Game Engine
+ * PRO-1.8.3: Unity Asset Store Integration
+ *
+ * Features:
+ * - Asset Store Browser (search, preview, categories)
+ * - Unity Package Manager integration (UPM)
+ * - Package version selection
+ * - Dependency management
+ * - Git package support
+ */
+class AssetStoreBrowser {
+    constructor(config) {
+        this.cache = new Map();
+        this.callbacks = {};
+        this.currentUser = null;
+        this.config = {
+            apiBaseUrl: 'https://assetstore.unity.com/api',
+            cacheDuration: 300000, // 5 minutes
+            defaultPageSize: 24,
+            ...config,
+        };
+    }
+    // ─── Authentication ────────────────────────────────────
+    async login(sessionToken) {
+        this.config.sessionToken = sessionToken;
+        // In real implementation, validate token and fetch user data
+        this.currentUser = {
+            id: 'user-123',
+            name: 'Demo User',
+            email: 'demo@example.com',
+            purchases: [],
+            favorites: [],
+        };
+        this.callbacks.onLogin?.(this.currentUser);
+        return this.currentUser;
+    }
+    logout() {
+        this.config.sessionToken = undefined;
+        this.currentUser = null;
+        this.callbacks.onLogout?.();
+    }
+    isLoggedIn() {
+        return this.config.sessionToken !== undefined && this.currentUser !== null;
+    }
+    getCurrentUser() {
+        return this.currentUser;
+    }
+    // ─── Search & Browse ───────────────────────────────────
+    async search(query) {
+        const cacheKey = `search:${JSON.stringify(query)}`;
+        const cached = this.getFromCache(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        // In real implementation, this would call the Asset Store API
+        // For now, return mock data
+        const result = await this.mockSearch(query);
+        this.setCache(cacheKey, result);
+        this.callbacks.onSearchComplete?.(result);
+        return result;
+    }
+    async getAsset(assetId) {
+        const cacheKey = `asset:${assetId}`;
+        const cached = this.getFromCache(cacheKey);
+        if (cached) {
+            return cached;
+        }
+        // In real implementation, fetch asset details
+        const asset = await this.mockGetAsset(assetId);
+        if (asset) {
+            this.setCache(cacheKey, asset);
+        }
+        return asset;
+    }
+    async getAssetReviews(assetId, page = 1) {
+        // In real implementation, fetch reviews from API
+        return {
+            reviews: [],
+            total: 0,
+            page,
+        };
+    }
+    async getCategories() {
+        return [
+            { id: '3d', name: '3D', count: 45000 },
+            { id: '2d', name: '2D', count: 15000 },
+            { id: 'add-ons', name: 'Add-Ons', count: 8000 },
+            { id: 'audio', name: 'Audio', count: 5000 },
+            { id: 'templates', name: 'Templates', count: 3000 },
+            { id: 'tools', name: 'Tools', count: 12000 },
+            { id: 'vfx', name: 'VFX', count: 4000 },
+            { id: 'ai', name: 'AI', count: 1000 },
+        ];
+    }
+    async getPopularAssets(count = 10) {
+        const result = await this.search({
+            sortBy: 'popularity',
+            pageSize: count,
+        });
+        return result.assets;
+    }
+    async getNewAssets(count = 10) {
+        const result = await this.search({
+            sortBy: 'newest',
+            pageSize: count,
+        });
+        return result.assets;
+    }
+    async getFreeAssets(count = 10) {
+        const result = await this.search({
+            pricing: 'free',
+            sortBy: 'popularity',
+            pageSize: count,
+        });
+        return result.assets;
+    }
+    // ─── User Library ──────────────────────────────────────
+    async getPurchasedAssets() {
+        if (!this.isLoggedIn()) {
+            throw new Error('Must be logged in to view purchases');
+        }
+        // In real implementation, fetch from API
+        return [];
+    }
+    async getFavorites() {
+        if (!this.isLoggedIn()) {
+            throw new Error('Must be logged in to view favorites');
+        }
+        return [];
+    }
+    async addToFavorites(assetId) {
+        if (!this.isLoggedIn()) {
+            throw new Error('Must be logged in to add favorites');
+        }
+        if (this.currentUser) {
+            this.currentUser.favorites.push(assetId);
+        }
+    }
+    async removeFromFavorites(assetId) {
+        if (!this.isLoggedIn()) {
+            throw new Error('Must be logged in to remove favorites');
+        }
+        if (this.currentUser) {
+            this.currentUser.favorites = this.currentUser.favorites.filter((id) => id !== assetId);
+        }
+    }
+    // ─── Download & Import ─────────────────────────────────
+    async initiateDownload(assetId) {
+        if (!this.isLoggedIn()) {
+            throw new Error('Must be logged in to download');
+        }
+        // Check if owned
+        const asset = await this.getAsset(assetId);
+        if (!asset) {
+            throw new Error('Asset not found');
+        }
+        if (!asset.isFree && !asset.isOwned) {
+            throw new Error('Asset must be purchased first');
+        }
+        // In real implementation, get download URL from API
+        const downloadInfo = {
+            assetId,
+            downloadUrl: `https://download.unity.com/asset/${assetId}/download`,
+            fileName: `${asset.name.replace(/\s+/g, '_')}_v${asset.version}.unitypackage`,
+            fileSize: asset.fileSize,
+            checksum: 'sha256:abc123...',
+            expiresAt: Date.now() + 3600000, // 1 hour
+        };
+        this.callbacks.onDownloadStart?.(downloadInfo);
+        return downloadInfo;
+    }
+    async importToProject(assetId, projectPath, options) {
+        await this.initiateDownload(assetId);
+        // In real implementation:
+        // 1. Download the .unitypackage
+        // 2. Extract contents
+        // 3. Copy to project Assets folder
+        // 4. Handle .meta files
+        const result = {
+            success: true,
+            assetId,
+            importedFiles: [],
+            skippedFiles: [],
+            errors: [],
+        };
+        this.callbacks.onImportComplete?.(result);
+        return result;
+    }
+    // ─── Caching ───────────────────────────────────────────
+    getFromCache(key) {
+        const cached = this.cache.get(key);
+        if (!cached) {
+            return null;
+        }
+        if (Date.now() - cached.timestamp > this.config.cacheDuration) {
+            this.cache.delete(key);
+            return null;
+        }
+        return cached.data;
+    }
+    setCache(key, data) {
+        this.cache.set(key, { data, timestamp: Date.now() });
+    }
+    clearCache() {
+        this.cache.clear();
+    }
+    // ─── Mock Data ─────────────────────────────────────────
+    async mockSearch(query) {
+        // Simulate API delay
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        const mockAssets = [
+            {
+                id: 'asset-1',
+                name: 'Universal Platformer Kit',
+                publisher: 'GameDev Tools',
+                publisherId: 'pub-1',
+                category: 'templates',
+                shortDescription: 'Complete 2D/3D platformer template with enemies, items, and level editor.',
+                description: 'Full description here...',
+                price: 0,
+                currency: 'USD',
+                isFree: true,
+                rating: 4.8,
+                ratingCount: 234,
+                thumbnailUrl: 'https://example.com/thumb1.png',
+                previewImages: [],
+                unityVersions: ['2021.3', '2022.3', '6000.0'],
+                minUnityVersion: '2021.3',
+                fileSize: 52428800,
+                lastUpdated: '2024-01-15',
+                releaseDate: '2023-06-01',
+                version: '2.5.0',
+                tags: ['platformer', '2d', '3d', 'template'],
+                isOwned: false,
+                renderPipelines: ['builtin', 'urp'],
+                url: 'https://assetstore.unity.com/packages/templates/platformer-kit',
+            },
+            {
+                id: 'asset-2',
+                name: 'Pro Shader Collection',
+                publisher: 'Shader Masters',
+                publisherId: 'pub-2',
+                category: 'vfx',
+                shortDescription: 'Professional shader pack with 100+ effects for URP and HDRP.',
+                description: 'Full description here...',
+                price: 49.99,
+                currency: 'USD',
+                isFree: false,
+                rating: 4.9,
+                ratingCount: 567,
+                thumbnailUrl: 'https://example.com/thumb2.png',
+                previewImages: [],
+                unityVersions: ['2022.3', '6000.0'],
+                minUnityVersion: '2022.3',
+                fileSize: 104857600,
+                lastUpdated: '2024-02-01',
+                releaseDate: '2022-01-15',
+                version: '5.0.0',
+                tags: ['shaders', 'vfx', 'urp', 'hdrp'],
+                isOwned: false,
+                renderPipelines: ['urp', 'hdrp'],
+                url: 'https://assetstore.unity.com/packages/vfx/shaders/pro-shaders',
+            },
+            {
+                id: 'asset-3',
+                name: 'Ultimate Inventory System',
+                publisher: 'RPG Tools',
+                publisherId: 'pub-3',
+                category: 'tools',
+                shortDescription: 'Complete inventory system with crafting, equipment, and storage.',
+                description: 'Full description here...',
+                price: 29.99,
+                currency: 'USD',
+                isFree: false,
+                rating: 4.7,
+                ratingCount: 189,
+                thumbnailUrl: 'https://example.com/thumb3.png',
+                previewImages: [],
+                unityVersions: ['2021.3', '2022.3', '6000.0'],
+                minUnityVersion: '2021.3',
+                fileSize: 31457280,
+                lastUpdated: '2024-01-20',
+                releaseDate: '2021-08-10',
+                version: '3.2.1',
+                tags: ['inventory', 'rpg', 'crafting', 'ui'],
+                isOwned: false,
+                renderPipelines: ['builtin', 'urp', 'hdrp'],
+                url: 'https://assetstore.unity.com/packages/tools/inventory',
+            },
+        ];
+        // Filter based on query
+        let filtered = [...mockAssets];
+        if (query.query) {
+            const searchLower = query.query.toLowerCase();
+            filtered = filtered.filter((a) => a.name.toLowerCase().includes(searchLower) ||
+                a.tags.some((t) => t.toLowerCase().includes(searchLower)));
+        }
+        if (query.category) {
+            filtered = filtered.filter((a) => a.category === query.category);
+        }
+        if (query.pricing === 'free') {
+            filtered = filtered.filter((a) => a.isFree);
+        }
+        else if (query.pricing === 'paid') {
+            filtered = filtered.filter((a) => !a.isFree);
+        }
+        if (query.minRating) {
+            filtered = filtered.filter((a) => a.rating >= query.minRating);
+        }
+        if (query.renderPipeline) {
+            filtered = filtered.filter((a) => a.renderPipelines.includes(query.renderPipeline));
+        }
+        // Sort
+        switch (query.sortBy) {
+            case 'rating':
+                filtered.sort((a, b) => b.rating - a.rating);
+                break;
+            case 'price_asc':
+                filtered.sort((a, b) => a.price - b.price);
+                break;
+            case 'price_desc':
+                filtered.sort((a, b) => b.price - a.price);
+                break;
+            case 'newest':
+                filtered.sort((a, b) => new Date(b.releaseDate).getTime() - new Date(a.releaseDate).getTime());
+                break;
+            case 'popularity':
+            default:
+                filtered.sort((a, b) => b.ratingCount - a.ratingCount);
+        }
+        const page = query.page ?? 1;
+        const pageSize = query.pageSize ?? this.config.defaultPageSize;
+        const start = (page - 1) * pageSize;
+        const paged = filtered.slice(start, start + pageSize);
+        return {
+            total: filtered.length,
+            page,
+            pageSize,
+            totalPages: Math.ceil(filtered.length / pageSize),
+            assets: paged,
+        };
+    }
+    async mockGetAsset(assetId) {
+        const result = await this.mockSearch({});
+        return result.assets.find((a) => a.id === assetId) ?? null;
+    }
+    // ─── Callbacks ─────────────────────────────────────────
+    setCallbacks(callbacks) {
+        this.callbacks = { ...this.callbacks, ...callbacks };
+    }
+}
+// ============================================================
+// Package Manager
+// ============================================================
+class UnityPackageManager {
+    constructor() {
+        this.installedPackages = new Map();
+        this.registryCache = new Map();
+        this.callbacks = {};
+        this.manifest = {
+            dependencies: {},
+        };
+        this.lockFile = {
+            dependencies: {},
+        };
+        // Add default Unity packages
+        this.addDefaultPackages();
+    }
+    addDefaultPackages() {
+        // Common Unity packages available in registry
+        const defaultPackages = [
+            {
+                name: 'com.unity.render-pipelines.universal',
+                displayName: 'Universal RP',
+                version: '14.0.10',
+                description: 'The Universal Render Pipeline (URP) is a prebuilt Scriptable Render Pipeline.',
+                unity: '2022.3',
+                dependencies: {
+                    'com.unity.render-pipelines.core': '14.0.10',
+                    'com.unity.shadergraph': '14.0.10',
+                },
+                source: 'registry',
+                isUnityPackage: true,
+                isInstalled: false,
+                hasUpdate: false,
+                versions: ['14.0.10', '14.0.9', '14.0.8', '12.1.13'],
+            },
+            {
+                name: 'com.unity.render-pipelines.high-definition',
+                displayName: 'High Definition RP',
+                version: '14.0.10',
+                description: 'The High Definition Render Pipeline (HDRP) is a prebuilt Scriptable Render Pipeline.',
+                unity: '2022.3',
+                dependencies: {
+                    'com.unity.render-pipelines.core': '14.0.10',
+                    'com.unity.shadergraph': '14.0.10',
+                    'com.unity.visualeffectgraph': '14.0.10',
+                },
+                source: 'registry',
+                isUnityPackage: true,
+                isInstalled: false,
+                hasUpdate: false,
+                versions: ['14.0.10', '14.0.9', '14.0.8', '12.1.13'],
+            },
+            {
+                name: 'com.unity.inputsystem',
+                displayName: 'Input System',
+                version: '1.7.0',
+                description: "A new input system which can be used as a more extensible and customizable alternative to Unity's built-in input system.",
+                unity: '2019.4',
+                dependencies: {},
+                source: 'registry',
+                isUnityPackage: true,
+                isInstalled: false,
+                hasUpdate: false,
+                versions: ['1.7.0', '1.6.3', '1.5.1', '1.4.4'],
+            },
+            {
+                name: 'com.unity.cinemachine',
+                displayName: 'Cinemachine',
+                version: '2.9.7',
+                description: 'Smart camera tools for passionate creators.',
+                unity: '2019.4',
+                dependencies: {},
+                source: 'registry',
+                isUnityPackage: true,
+                isInstalled: false,
+                hasUpdate: false,
+                versions: ['2.9.7', '2.9.5', '2.8.9', '2.6.17'],
+            },
+            {
+                name: 'com.unity.textmeshpro',
+                displayName: 'TextMesh Pro',
+                version: '3.0.6',
+                description: 'TextMesh Pro is the ultimate text solution for Unity.',
+                unity: '2019.4',
+                dependencies: {},
+                source: 'registry',
+                isUnityPackage: true,
+                isInstalled: true, // Usually pre-installed
+                hasUpdate: false,
+                versions: ['3.0.6', '3.0.5', '3.0.4'],
+            },
+            {
+                name: 'com.unity.addressables',
+                displayName: 'Addressables',
+                version: '1.21.19',
+                description: 'The Addressable Asset System allows the developer to ask for an asset via its address.',
+                unity: '2019.4',
+                dependencies: {
+                    'com.unity.scriptablebuild-pipeline': '1.21.21',
+                },
+                source: 'registry',
+                isUnityPackage: true,
+                isInstalled: false,
+                hasUpdate: false,
+                versions: ['1.21.19', '1.21.18', '1.19.19'],
+            },
+            {
+                name: 'com.unity.netcode.gameobjects',
+                displayName: 'Netcode for GameObjects',
+                version: '1.8.0',
+                description: 'Unity Netcode for GameObjects provides networking capabilities for GameObject and MonoBehaviour based projects.',
+                unity: '2021.3',
+                dependencies: {
+                    'com.unity.nuget.mono-cecil': '1.11.4',
+                    'com.unity.transport': '1.4.0',
+                },
+                source: 'registry',
+                isUnityPackage: true,
+                isInstalled: false,
+                hasUpdate: false,
+                versions: ['1.8.0', '1.7.1', '1.6.0', '1.5.2'],
+            },
+            {
+                name: 'com.unity.ai.navigation',
+                displayName: 'AI Navigation',
+                version: '1.1.5',
+                description: 'Use the AI Navigation package to create Non-Player Characters (NPCs) that can navigate the game environment.',
+                unity: '2022.2',
+                dependencies: {},
+                source: 'registry',
+                isUnityPackage: true,
+                isInstalled: false,
+                hasUpdate: false,
+                versions: ['1.1.5', '1.1.4', '1.1.3'],
+            },
+        ];
+        for (const pkg of defaultPackages) {
+            this.registryCache.set(pkg.name, [pkg]);
+            if (pkg.isInstalled) {
+                this.installedPackages.set(pkg.name, pkg);
+                this.manifest.dependencies[pkg.name] = pkg.version;
+            }
+        }
+    }
+    // ─── Package Discovery ─────────────────────────────────
+    async searchPackages(query) {
+        const results = [];
+        const queryLower = query.toLowerCase();
+        for (const [, packages] of this.registryCache) {
+            for (const pkg of packages) {
+                if (pkg.name.toLowerCase().includes(queryLower) ||
+                    pkg.displayName.toLowerCase().includes(queryLower) ||
+                    pkg.description?.toLowerCase().includes(queryLower) ||
+                    pkg.keywords?.some((k) => k.toLowerCase().includes(queryLower))) {
+                    results.push(pkg);
+                }
+            }
+        }
+        return results;
+    }
+    async getPackage(packageName) {
+        // Check installed first
+        const installed = this.installedPackages.get(packageName);
+        if (installed) {
+            return installed;
+        }
+        // Check registry cache
+        const cached = this.registryCache.get(packageName);
+        if (cached && cached.length > 0) {
+            return cached[0];
+        }
+        return null;
+    }
+    async getPackageVersions(packageName) {
+        const pkg = await this.getPackage(packageName);
+        return pkg?.versions ?? [];
+    }
+    getInstalledPackages() {
+        return Array.from(this.installedPackages.values());
+    }
+    // ─── Package Installation ──────────────────────────────
+    async installPackage(packageName, version) {
+        const pkg = await this.getPackage(packageName);
+        if (!pkg) {
+            return {
+                success: false,
+                packageName,
+                error: `Package ${packageName} not found`,
+            };
+        }
+        const targetVersion = version ?? pkg.version;
+        // Check dependencies
+        const depsToInstall = await this.resolveDependencies(packageName, targetVersion);
+        // Install dependencies first
+        for (const [depName, depVersion] of Object.entries(depsToInstall)) {
+            if (!this.installedPackages.has(depName)) {
+                await this.installPackage(depName, depVersion);
+            }
+        }
+        // Install the package
+        const installedPkg = {
+            ...pkg,
+            version: targetVersion,
+            resolvedVersion: targetVersion,
+            isInstalled: true,
+        };
+        this.installedPackages.set(packageName, installedPkg);
+        this.manifest.dependencies[packageName] = targetVersion;
+        this.lockFile.dependencies[packageName] = {
+            version: targetVersion,
+            depth: 0,
+            source: pkg.source,
+            dependencies: pkg.dependencies,
+        };
+        this.callbacks.onPackageInstalled?.(installedPkg);
+        return {
+            success: true,
+            packageName,
+            version: targetVersion,
+            dependencies: Object.keys(depsToInstall),
+        };
+    }
+    async uninstallPackage(packageName) {
+        const pkg = this.installedPackages.get(packageName);
+        if (!pkg) {
+            return {
+                success: false,
+                packageName,
+                error: `Package ${packageName} is not installed`,
+            };
+        }
+        // Check if other packages depend on this
+        const dependents = this.findDependents(packageName);
+        if (dependents.length > 0) {
+            return {
+                success: false,
+                packageName,
+                error: `Cannot uninstall: required by ${dependents.join(', ')}`,
+                dependents,
+            };
+        }
+        this.installedPackages.delete(packageName);
+        delete this.manifest.dependencies[packageName];
+        delete this.lockFile.dependencies[packageName];
+        this.callbacks.onPackageUninstalled?.(packageName);
+        return {
+            success: true,
+            packageName,
+        };
+    }
+    async updatePackage(packageName, version) {
+        const installed = this.installedPackages.get(packageName);
+        if (!installed) {
+            return {
+                success: false,
+                packageName,
+                error: `Package ${packageName} is not installed`,
+            };
+        }
+        const targetVersion = version ?? installed.latestVersion ?? installed.version;
+        if (targetVersion === installed.version) {
+            return {
+                success: true,
+                packageName,
+                version: targetVersion,
+                message: 'Already at target version',
+            };
+        }
+        return this.installPackage(packageName, targetVersion);
+    }
+    async updateAllPackages() {
+        const results = [];
+        for (const pkg of this.installedPackages.values()) {
+            if (pkg.hasUpdate && pkg.latestVersion) {
+                const result = await this.updatePackage(pkg.name);
+                results.push(result);
+            }
+        }
+        return results;
+    }
+    // ─── Git Packages ──────────────────────────────────────
+    async installGitPackage(url, ref) {
+        // Parse Git URL
+        const match = url.match(/([^/]+\/[^/]+)(?:\.git)?(?:#(.+))?$/);
+        if (!match) {
+            return {
+                success: false,
+                packageName: url,
+                error: 'Invalid Git URL format',
+            };
+        }
+        const repoPath = match[1];
+        const gitRef = ref ?? match[2] ?? 'main';
+        const packageName = `com.${repoPath.replace('/', '.')}`;
+        const pkg = {
+            name: packageName,
+            displayName: repoPath.split('/')[1],
+            version: gitRef,
+            description: `Git package from ${url}`,
+            unity: '2019.4',
+            dependencies: {},
+            source: 'git',
+            isUnityPackage: false,
+            isInstalled: true,
+            hasUpdate: false,
+            repository: {
+                type: 'git',
+                url,
+            },
+        };
+        this.installedPackages.set(packageName, pkg);
+        this.manifest.dependencies[packageName] = `${url}#${gitRef}`;
+        this.lockFile.dependencies[packageName] = {
+            version: gitRef,
+            depth: 0,
+            source: 'git',
+            dependencies: {},
+            url,
+            hash: gitRef,
+        };
+        this.callbacks.onPackageInstalled?.(pkg);
+        return {
+            success: true,
+            packageName,
+            version: gitRef,
+        };
+    }
+    // ─── Scoped Registries ─────────────────────────────────
+    addScopedRegistry(registry) {
+        if (!this.manifest.scopedRegistries) {
+            this.manifest.scopedRegistries = [];
+        }
+        // Remove existing with same name
+        this.manifest.scopedRegistries = this.manifest.scopedRegistries.filter((r) => r.name !== registry.name);
+        this.manifest.scopedRegistries.push(registry);
+        this.callbacks.onRegistryAdded?.(registry);
+    }
+    removeScopedRegistry(name) {
+        if (!this.manifest.scopedRegistries) {
+            return false;
+        }
+        const before = this.manifest.scopedRegistries.length;
+        this.manifest.scopedRegistries = this.manifest.scopedRegistries.filter((r) => r.name !== name);
+        return this.manifest.scopedRegistries.length < before;
+    }
+    getScopedRegistries() {
+        return this.manifest.scopedRegistries ?? [];
+    }
+    // ─── Dependency Resolution ─────────────────────────────
+    async resolveDependencies(packageName, version) {
+        const pkg = await this.getPackage(packageName);
+        if (!pkg) {
+            return {};
+        }
+        return pkg.dependencies;
+    }
+    findDependents(packageName) {
+        const dependents = [];
+        for (const [name, pkg] of this.installedPackages) {
+            if (name !== packageName && pkg.dependencies[packageName]) {
+                dependents.push(name);
+            }
+        }
+        return dependents;
+    }
+    // ─── Manifest Operations ───────────────────────────────
+    getManifest() {
+        return { ...this.manifest };
+    }
+    getLockFile() {
+        return { ...this.lockFile };
+    }
+    generateManifestJson() {
+        return JSON.stringify(this.manifest, null, 2);
+    }
+    generateLockFileJson() {
+        return JSON.stringify(this.lockFile, null, 2);
+    }
+    // ─── Callbacks ─────────────────────────────────────────
+    setCallbacks(callbacks) {
+        this.callbacks = { ...this.callbacks, ...callbacks };
+    }
+}
+// ============================================================
+// Factory Functions
+// ============================================================
+function createAssetStoreBrowser(config) {
+    return new AssetStoreBrowser(config);
+}
+function createUnityPackageManager() {
+    return new UnityPackageManager();
+}
+
+export { AssetStoreBrowser, UnityPackageManager, createAssetStoreBrowser, createUnityPackageManager };
+//# sourceMappingURL=UnityAssetStore.js.map