ThirdPartyPackageManager

Editor-time system for importing, cataloging, and processing third-party Unity Asset Store packages. Downloads a centralized catalog from Google Sheets, manages package manifests (package.json), and runs configurable pre/post-processing pipelines to normalize imported assets into the project's conventions.

Architecture

Import Flow

Core Classes

Class	Description
ThirdPartyPackageManager	Static entry point — initializes catalog, provides package lookup
ThirdPartyPackageCatalog	Dictionary-backed collection of ThirdPartyPackageInfo keyed by ProductID
ThirdPartyPackageManifest	package.json parser and creator — discovers manifests from Third-Party folders
ThirdPartyPackageProcessor	Static processor pipeline — runs pre/post processors on imported packages
ThirdPartyPackageUtility	Google Sheets CSV download, local caching, deserialization utilities

Subsystems

Subsystem	Description
Editor	UI components — PackageManagerExtension, import/export/prepare windows (documented separately)
Internals	Unity Asset Store API wrappers — Package, Product, PackageDatabase, PackageImport (documented separately)
Package	Data types — ThirdPartyPackage, ThirdPartyPackageInfo, ThirdPartyPackageVersion (documented separately)
Processor	Processing pipeline — abstract Processor base, ProcessorTable, concrete pre/post processors (documented separately)

Key Concepts

Catalog Data Source

Package metadata is stored in a Google Sheets spreadsheet, exported as CSV. The catalog sheet (GID 0) contains one row per package with columns: ProductName, ProductID, PackageName, CatalogID, ImportFolder, Hash. Each package also has its own sheet (identified by CatalogID) containing a ProcessorTable — rename/remap rules organized by context sections.

Local Caching

Downloaded CSV data is cached to Application.persistentDataPath/Third-Party Packages/. The catalog is cached as catalog.cache. Per-package processor tables are cached with filenames {CatalogID}_{Hash}, and stale caches (same CatalogID, different hash) are automatically cleaned up.

Processing Pipeline

Import processing is split into two phases:

Phase	Processors	Purpose
Pre-process	PathProcessor, PrepareProcessor	Normalize paths and prepare assets before Unity import
Post-process	FBXProcessor, MaterialProcessor, MetaProcessor	Fix FBX settings, materials, and meta files after import

Each processor uses a ProcessorTable — a context-aware lookup table that maps original asset names/paths to their desired values. Contexts include VARIABLES, DIRECTORIES, FILES, MATERIALS, MESHES, and ANIMATIONS.

Engine Module Integration

The system depends on the ModuleManager's EngineModule named "Third-Party". This module provides the workspace and mount path where third-party packages are stored.

Package Manifests

Each imported package gets a package.json manifest (UPM format) stored alongside it. Manifests are auto-discovered from Third-Party/ and Assets/Third-Party/ folders at editor startup. The manifest tracks name, version, Unity version compatibility, and author information.

Quick Start

using Paragon.Editor.ThirdPartyPackageImporter;

// Wait for initialization (downloads catalog from Google Sheets)
while (!ThirdPartyPackageManager.Initialized) { /* wait */ }

// Look up a package by Asset Store product ID
ThirdPartyPackageInfo info = ThirdPartyPackageManager.GetPackage(12345);

// Get all registered packages
foreach (ThirdPartyPackageInfo package in ThirdPartyPackageManager.GetPackages())
{
    Debug.Log($"{package.ProductName} (ID: {package.ProductID})");
}

// Check if a manifest exists for a package
if (ThirdPartyPackageManifest.TryGetManifest("com.third-party.package-name", out var manifest))
{
    Debug.Log($"Installed: {manifest.displayName} v{manifest.version}");
}