asset details (WIP)

This commit is contained in:
2026-03-24 13:42:53 +00:00
parent 92a1ffd735
commit fb56b0eb72
83 changed files with 1256 additions and 1112 deletions
@@ -79,7 +79,7 @@ public final class PackerAssetDetailsService {
outputContract.availableCodecs(),
outputContract.codecConfigurationFieldsByCodec(),
metadataFields(outputContract.metadataFields(), declaration.outputMetadata()),
resolveBankCompositionDetails(runtimeAsset, declaration),
resolveBankCompositionDetails(snapshot, runtimeAsset, declaration),
diagnostics);
return new GetAssetDetailsResult(
diagnostics.stream().anyMatch(PackerDiagnostic::blocking) ? PackerOperationStatus.PARTIAL : PackerOperationStatus.SUCCESS,
@@ -128,11 +128,14 @@ public final class PackerAssetDetailsService {
}
private PackerBankCompositionDetails resolveBankCompositionDetails(
final PackerRuntimeSnapshot snapshot,
final PackerRuntimeAsset runtimeAsset,
final PackerAssetDeclaration declaration) {
final var walkProjection = runtimeAsset.walkProjection();
final Map<String, PackerRuntimeWalkFile> walkFilesByPath = new LinkedHashMap<>();
walkProjection.buildCandidateFiles().forEach(file -> walkFilesByPath.put(file.relativePath(), file));
final Optional<PackerAssetCacheEntry> assetCacheEntry = runtimeAsset.registryEntry()
.flatMap(entry -> snapshot.cacheState().findAsset(entry.assetId()));
final List<PackerBankCompositionFile> availableFiles = walkProjection.buildCandidateFiles().stream()
.filter(file -> file.diagnostics().stream().noneMatch(PackerDiagnostic::blocking))
@@ -140,7 +143,7 @@ public final class PackerAssetDetailsService {
.toList();
final List<PackerBankCompositionFile> selectedFiles = selectedPathsFor(declaration).stream()
.map(path -> resolveSelectedBankFile(runtimeAsset.assetRoot(), path, walkFilesByPath))
.map(path -> resolveSelectedBankFile(runtimeAsset.assetRoot(), path, walkFilesByPath, assetCacheEntry))
.flatMap(Optional::stream)
.toList();
@@ -160,11 +163,16 @@ public final class PackerAssetDetailsService {
private Optional<PackerBankCompositionFile> resolveSelectedBankFile(
Path assetRoot,
String relativePath,
Map<String, PackerRuntimeWalkFile> walkFilesByPath) {
Map<String, PackerRuntimeWalkFile> walkFilesByPath,
Optional<PackerAssetCacheEntry> assetCacheEntry) {
final PackerRuntimeWalkFile runtimeWalkFile = walkFilesByPath.get(relativePath);
if (runtimeWalkFile != null) {
return Optional.of(toBankCompositionFile(runtimeWalkFile));
}
final Optional<PackerFileCacheEntry> cachedFile = assetCacheEntry.flatMap(entry -> entry.findFile(relativePath));
if (cachedFile.isPresent()) {
return Optional.of(toBankCompositionFile(cachedFile.get()));
}
final Path filePath = assetRoot.resolve(relativePath).toAbsolutePath().normalize();
if (!Files.isRegularFile(filePath)) {
@@ -194,6 +202,16 @@ public final class PackerAssetDetailsService {
file.metadata());
}
private PackerBankCompositionFile toBankCompositionFile(PackerFileCacheEntry file) {
return new PackerBankCompositionFile(
file.relativePath(),
Path.of(file.relativePath()).getFileName().toString(),
file.size(),
file.lastModified(),
file.fingerprint(),
file.metadata());
}
private List<PackerCodecConfigurationField> metadataFields(
List<PackerCodecConfigurationField> definitions,
Map<String, String> outputMetadata) {
@@ -49,7 +49,88 @@ public final class PackerReadMessageMapper {
file.size(),
file.lastModified(),
file.fingerprint(),
file.metadata());
normalizeMetadata(file.metadata()));
}
private static Map<String, Object> normalizeMetadata(Map<String, Object> metadata) {
return metadata.entrySet().stream().collect(Collectors.toMap(
Map.Entry::getKey,
entry -> normalizeMetadataValue(entry.getValue()),
(left, right) -> left,
java.util.LinkedHashMap::new));
}
private static Object normalizeMetadataValue(Object value) {
if (value == null
|| value instanceof String
|| value instanceof Number
|| value instanceof Boolean) {
return value;
}
if (value instanceof PackerTileIndexedV1 tile) {
final List<Integer> paletteIndices = new java.util.ArrayList<>(tile.paletteIndices().length);
for (byte paletteIndex : tile.paletteIndices()) {
paletteIndices.add(Byte.toUnsignedInt(paletteIndex));
}
return Map.of(
"width", tile.width(),
"height", tile.height(),
"paletteIndices", List.copyOf(paletteIndices));
}
if (value instanceof PackerPaletteV1 palette) {
final List<Integer> originalArgb8888 = new java.util.ArrayList<>(palette.originalArgb8888().length);
for (int argb : palette.originalArgb8888()) {
originalArgb8888.add(argb);
}
final List<Integer> convertedRgb565 = new java.util.ArrayList<>(palette.convertedRgb565().length);
for (short rgb565 : palette.convertedRgb565()) {
convertedRgb565.add(Short.toUnsignedInt(rgb565));
}
return Map.of(
"originalArgb8888", List.copyOf(originalArgb8888),
"convertedRgb565", List.copyOf(convertedRgb565));
}
if (value instanceof Map<?, ?> nestedMap) {
final java.util.LinkedHashMap<String, Object> normalized = new java.util.LinkedHashMap<>();
nestedMap.forEach((key, nestedValue) -> normalized.put(String.valueOf(key), normalizeMetadataValue(nestedValue)));
return Map.copyOf(normalized);
}
if (value instanceof Iterable<?> iterable) {
final java.util.List<Object> normalized = new java.util.ArrayList<>();
iterable.forEach(item -> normalized.add(normalizeMetadataValue(item)));
return List.copyOf(normalized);
}
if (value.getClass().isArray()) {
if (value instanceof int[] intArray) {
final java.util.List<Integer> normalized = new java.util.ArrayList<>(intArray.length);
for (int item : intArray) {
normalized.add(item);
}
return List.copyOf(normalized);
}
if (value instanceof short[] shortArray) {
final java.util.List<Integer> normalized = new java.util.ArrayList<>(shortArray.length);
for (short item : shortArray) {
normalized.add(Short.toUnsignedInt(item));
}
return List.copyOf(normalized);
}
if (value instanceof byte[] byteArray) {
final java.util.List<Integer> normalized = new java.util.ArrayList<>(byteArray.length);
for (byte item : byteArray) {
normalized.add(Byte.toUnsignedInt(item));
}
return List.copyOf(normalized);
}
if (value instanceof Object[] objectArray) {
final java.util.List<Object> normalized = new java.util.ArrayList<>(objectArray.length);
for (Object item : objectArray) {
normalized.add(normalizeMetadataValue(item));
}
return List.copyOf(normalized);
}
}
return String.valueOf(value);
}
public static List<PackerAssetSummaryDTO> toAssetSummaryDTOs(List<PackerAssetSummary> summaries) {
@@ -121,6 +121,54 @@ final class PackerAssetDetailsServiceTest {
.anyMatch(diagnostic -> diagnostic.message().contains("Invalid tile dimensions for wrong-palette.png")));
}
@Test
void preservesSelectedFileMetadataFromCacheWhenSelectedFileIsMissingFromWalkProjection() throws Exception {
final Path projectRoot = copyFixture("workspaces/managed-basic", tempDir.resolve("managed-selected-metadata-cache"));
final Path assetRoot = projectRoot.resolve("assets/ui/atlas");
final Path manifestPath = assetRoot.resolve("asset.json");
writeTilePng(assetRoot.resolve("confirm.png"), 16);
final ObjectMapper mapper = new ObjectMapper();
final ObjectNode manifest = (ObjectNode) mapper.readTree(manifestPath.toFile());
final var artifacts = manifest.putArray("artifacts");
artifacts.addObject().put("file", "confirm.png").put("index", 0);
mapper.writerWithDefaultPrettyPrinter().writeValue(manifestPath.toFile(), manifest);
final var foundation = new PackerWorkspaceFoundation(mapper);
final var parser = new PackerAssetDeclarationParser(mapper);
final var assetWalker = new PackerAssetWalker(mapper);
final var cacheRepository = new FileSystemPackerCacheRepository(mapper);
final var assetMaterializer = new PackerRuntimeAssetMaterializer(assetWalker);
final var runtimeLoader = new PackerRuntimeLoader(foundation, parser, cacheRepository, assetMaterializer);
final PackerProjectContext project = project(projectRoot);
final var loadedSnapshot = runtimeLoader.load(project, 1L);
final var originalAsset = loadedSnapshot.assets().getFirst();
final var mutatedAsset = new p.packer.models.PackerRuntimeAsset(
originalAsset.assetRoot(),
originalAsset.manifestPath(),
originalAsset.registryEntry(),
originalAsset.parsedDeclaration(),
p.packer.models.PackerRuntimeWalkProjection.EMPTY,
originalAsset.walkDiagnostics());
final var mutatedSnapshot = new p.packer.models.PackerRuntimeSnapshot(
loadedSnapshot.generation(),
loadedSnapshot.registry(),
List.of(mutatedAsset),
loadedSnapshot.cacheState());
final var runtimeRegistry = new PackerRuntimeRegistry((ignoredProject, ignoredGeneration) -> mutatedSnapshot);
final var resolver = new PackerAssetReferenceResolver(foundation.lookup());
final PackerAssetDetailsService service = new PackerAssetDetailsService(runtimeRegistry, resolver);
final var result = service.getAssetDetails(new GetAssetDetailsRequest(project, AssetReference.forAssetId(1)));
final var selectedFile = result.details().bankComposition().selectedFiles().getFirst();
final var tile = (Map<?, ?>) selectedFile.metadata().get("tile");
final var palette = (Map<?, ?>) selectedFile.metadata().get("palette");
assertEquals(16, ((Number) tile.get("width")).intValue());
assertEquals(16, ((Number) tile.get("height")).intValue());
assertFalse(((List<?>) palette.get("originalArgb8888")).isEmpty());
}
@Test
void returnsUnregisteredDetailsForValidUnregisteredRootReference() throws Exception {
final Path projectRoot = copyFixture("workspaces/orphan-valid", tempDir.resolve("orphan"));