@kubohiroya/turbowarp-plus-editor-project-folder 0.10.0 → 0.12.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.ja.md +13 -3
- package/README.md +13 -3
- package/dist/THIRD_PARTY_NOTICES.md +376 -0
- package/dist/explorer.js +5 -2
- package/dist/index.js +47 -22
- package/dist/{shared-teFlHQ2X.js → shared-BYk-uDpM.js} +1 -1
- package/dist/{shared-zlHgCKDG.js → shared-cwwWtggC.js} +437 -80
- package/dist/source.d.ts +16 -0
- package/package.json +2 -2
- package/src/create-folder.ts +37 -2
- package/src/explorer.tsx +4 -0
- package/src/session.ts +43 -19
- package/src/source.ts +62 -8
package/src/create-folder.ts
CHANGED
|
@@ -1,7 +1,12 @@
|
|
|
1
|
-
import {extensionsFile, fileVersion, FolderError, manifestFile, projectFile, readFolder, sameBytes, unsupported} from './source.js';
|
|
1
|
+
import {extensionsFile, fileVersion, FolderError, manifestFile, paletteFile, projectFile, readFolder, sameBytes, unsupported} from './source.js';
|
|
2
2
|
import type {Storage} from './source.js';
|
|
3
|
+
import {editorDirectory, screenStateFile} from './explorer-state.js';
|
|
3
4
|
|
|
4
5
|
const manifests = new Set<string>([projectFile, manifestFile, extensionsFile]);
|
|
6
|
+
// Present only in a format 2 snapshot; readFolder checks that the manifest agrees.
|
|
7
|
+
const optionalManifests = new Set<string>([paletteFile]);
|
|
8
|
+
// The Editor's screen state, which sb3-toolchain unpacks from an SB3 that carries one. Opening the folder reads it.
|
|
9
|
+
const screenStatePath = `${editorDirectory}/${screenStateFile}`;
|
|
5
10
|
const sourceDirectories = ['assets', 'extensions'];
|
|
6
11
|
const sourcePath = /^(?:assets\/[a-f0-9]{32}\.[A-Za-z0-9]+|extensions\/[A-Za-z0-9._-]+\.(?:js|manifest\.json))$/u;
|
|
7
12
|
|
|
@@ -39,7 +44,8 @@ export async function createProjectFolder({directory, files, storage, overwrite
|
|
|
39
44
|
if (!files.has(filename)) return unsupported(`Missing ${filename}`);
|
|
40
45
|
}
|
|
41
46
|
for (const [filename, bytes] of files) {
|
|
42
|
-
if ((!manifests.has(filename) && !
|
|
47
|
+
if ((!manifests.has(filename) && !optionalManifests.has(filename) && filename !== screenStatePath && !sourcePath.test(filename)) ||
|
|
48
|
+
!(bytes instanceof Uint8Array)) {
|
|
43
49
|
return unsupported(`Invalid project folder entry: ${filename}`);
|
|
44
50
|
}
|
|
45
51
|
}
|
|
@@ -124,6 +130,35 @@ export async function createProjectFolder({directory, files, storage, overwrite
|
|
|
124
130
|
}
|
|
125
131
|
directories.set(name, {handle, entries: children});
|
|
126
132
|
}
|
|
133
|
+
// The Editor's own folder keeps its other files. The snapshot's screen state replaces the old one, and a
|
|
134
|
+
// snapshot without one does not leave the replaced project's screen behind.
|
|
135
|
+
const editorEntry = existing.get(editorDirectory);
|
|
136
|
+
if (files.has(screenStatePath)) {
|
|
137
|
+
if (editorEntry?.kind === 'file') await remove(directory, editorEntry);
|
|
138
|
+
const previous = await getDirectory(directory, editorDirectory);
|
|
139
|
+
if (previous && editorEntry?.kind === 'directory' && !await previous.isSameEntry(editorEntry)) {
|
|
140
|
+
throw new FolderError('conflict');
|
|
141
|
+
}
|
|
142
|
+
assertCurrent();
|
|
143
|
+
const handle = previous ?? await directory.getDirectoryHandle(editorDirectory, {create: true});
|
|
144
|
+
if (!previous) undo.push(async () => {
|
|
145
|
+
const found = await getDirectory(directory, editorDirectory);
|
|
146
|
+
if (found && await found.isSameEntry(handle)) await directory.removeEntry(editorDirectory);
|
|
147
|
+
});
|
|
148
|
+
directories.set(editorDirectory, {handle, entries: await directoryEntries(handle)});
|
|
149
|
+
} else if (editorEntry?.kind === 'directory') {
|
|
150
|
+
const handle = await getDirectory(directory, editorDirectory);
|
|
151
|
+
const stale = handle && (await directoryEntries(handle)).get(screenStateFile);
|
|
152
|
+
if (stale) await remove(handle, stale);
|
|
153
|
+
}
|
|
154
|
+
// A format 1 snapshot over a format 2 folder must not leave the old palette settings behind.
|
|
155
|
+
for (const name of optionalManifests) {
|
|
156
|
+
const entry = existing.get(name);
|
|
157
|
+
if (entry && !files.has(name)) {
|
|
158
|
+
await remove(directory, entry);
|
|
159
|
+
existing.delete(name);
|
|
160
|
+
}
|
|
161
|
+
}
|
|
127
162
|
// Publish the project JSON last, after the files it refers to.
|
|
128
163
|
const entries = [...files].sort(([a], [b]) => Number(manifests.has(a)) - Number(manifests.has(b)) ||
|
|
129
164
|
Number(a === projectFile) - Number(b === projectFile));
|
package/src/explorer.tsx
CHANGED
|
@@ -67,6 +67,7 @@ const messages = {
|
|
|
67
67
|
unsaved: 'Unsaved changes', staged: 'Added to Git index',
|
|
68
68
|
revisions: {committed: 'Committed', pushed: 'Pushed', merged: 'Pull request merged'},
|
|
69
69
|
project: 'Project data', manifest: 'Folder manifest', extensions: 'Embedded extensions',
|
|
70
|
+
palette: 'Block palette settings',
|
|
70
71
|
assetsDirectory: 'Costume and sound files', extensionsDirectory: 'Extension files',
|
|
71
72
|
costume: (sprite: string, name: string) => `${sprite} · costume ${name}`,
|
|
72
73
|
backdrop: (name: string) => `Stage · backdrop ${name}`,
|
|
@@ -86,6 +87,7 @@ const messages = {
|
|
|
86
87
|
unsaved: '未保存の変更あり', staged: 'Git のインデックスに追加済み',
|
|
87
88
|
revisions: {committed: 'コミット済み', pushed: 'プッシュ済み', merged: 'PR マージ済み'},
|
|
88
89
|
project: '作品データ', manifest: '作品フォルダの目録', extensions: '埋め込み拡張の一覧',
|
|
90
|
+
palette: 'ブロックパレットの設定',
|
|
89
91
|
assetsDirectory: 'コスチュームと音のファイル', extensionsDirectory: '拡張のファイル',
|
|
90
92
|
costume: (sprite: string, name: string) => `${sprite} のコスチューム ${name}`,
|
|
91
93
|
backdrop: (name: string) => `ステージの背景 ${name}`,
|
|
@@ -117,6 +119,8 @@ export function describeProjectFolder(project: Project, locale?: string, {manife
|
|
|
117
119
|
[at(assetsDirectory), message.assetsDirectory],
|
|
118
120
|
[at('extensions'), message.extensionsDirectory]
|
|
119
121
|
]);
|
|
122
|
+
// Only a format 2 folder names its block palette settings.
|
|
123
|
+
if (isObject(manifest) && typeof manifest.blockPalette === 'string') descriptions.set(at(manifest.blockPalette), message.palette);
|
|
120
124
|
const users = new Map<string, string[]>();
|
|
121
125
|
for (const target of Array.isArray(project.targets) ? project.targets : []) {
|
|
122
126
|
if (!isObject(target)) continue;
|
package/src/session.ts
CHANGED
|
@@ -1,5 +1,6 @@
|
|
|
1
|
-
import {assetKey, assetTypeFor, assertFolderUnchanged,
|
|
2
|
-
|
|
1
|
+
import {assetKey, assetTypeFor, assertFolderUnchanged, collapsePalette, encodePalette, expandPalette, extensionsFile, fileVersion,
|
|
2
|
+
equal, FolderError, manifestFile, paletteFile, parseProject, planExtensionSave, projectAssets, projectChanges, projectFile, readFolder,
|
|
3
|
+
readFolderUpdate, sameBytes, unsupported} from './source.js';
|
|
3
4
|
import type {Asset, AssetKind, FolderSource, FolderUpdate, JsonObject, Project, Storage} from './source.js';
|
|
4
5
|
import {applyBlockReload, planBlockReload} from './block-reload.js';
|
|
5
6
|
import type {ReloadTarget} from './block-reload.js';
|
|
@@ -145,10 +146,13 @@ type SaveDirectory = {directory: FileSystemDirectoryHandle; files: Map<string, U
|
|
|
145
146
|
type VMAsset = {assetId: string; dataFormat: string; data?: Uint8Array};
|
|
146
147
|
const encodeJson = (value: unknown) => new TextEncoder().encode(`${JSON.stringify(value, null, 2)}\n`);
|
|
147
148
|
|
|
148
|
-
|
|
149
|
-
|
|
149
|
+
// The folder uses source format 2 exactly when it has palette settings, and format 1 otherwise.
|
|
150
|
+
function saveManifest(source: FolderSource, added: Iterable<string>, removed: readonly string[], palette: boolean) {
|
|
151
|
+
const {blockPalette: _, ...value} = JSON.parse(new TextDecoder().decode(source.files.get(manifestFile))) as JsonObject;
|
|
150
152
|
const entries = (value.archiveEntries as string[]).filter(name => !removed.includes(name));
|
|
151
|
-
|
|
153
|
+
// Same key order as the toolchain writes: the palette file comes last.
|
|
154
|
+
return encodeJson({...value, formatVersion: palette ? 2 : 1, archiveEntries: [...entries, ...added],
|
|
155
|
+
...palette ? {blockPalette: paletteFile} : {}});
|
|
152
156
|
}
|
|
153
157
|
|
|
154
158
|
export function createFolderSession(vm: FolderVM, host: FolderHost) {
|
|
@@ -216,12 +220,25 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
|
|
|
216
220
|
const changed = () => {revision++; notifyEdits();};
|
|
217
221
|
const planSave = (session: Session, edited: Project) => {
|
|
218
222
|
const {source} = session;
|
|
219
|
-
|
|
223
|
+
// Edits apply to the project as the VM saw it, with palette comments in full, so that a renamed sprite keeps
|
|
224
|
+
// its settings. The comments then move back to block-palette.json for the folder.
|
|
225
|
+
const expanded = projectChanges(expandPalette(source.project, source.palette), session.baseline, edited,
|
|
226
|
+
identity(session, edited));
|
|
227
|
+
const collapsed = expanded ? collapsePalette(expanded) : null;
|
|
228
|
+
// A change to palette settings alone leaves the project file as it was.
|
|
229
|
+
const result = collapsed && !equal(collapsed.project, source.project) ? collapsed.project : null;
|
|
230
|
+
const palette = collapsed ? collapsed.document : source.palette;
|
|
231
|
+
const paletteBytes = palette ? encodePalette(palette) : null;
|
|
232
|
+
const previousPalette = source.files.get(paletteFile) ?? null;
|
|
233
|
+
const paletteChanged = paletteBytes === null ? previousPalette !== null :
|
|
234
|
+
previousPalette === null || !sameBytes(paletteBytes, previousPalette);
|
|
220
235
|
const extensionSave = planExtensionSave(source, result ?? source.project);
|
|
221
236
|
const needed = projectAssets(extensionSave.project);
|
|
222
237
|
const added = [...needed].filter(([name]) => !source.bytes.has(name));
|
|
223
238
|
const removed = [...source.bytes.keys()].filter(name => !needed.has(name));
|
|
224
|
-
|
|
239
|
+
// The manifest changes with the asset list and when the folder moves between format 1 and 2.
|
|
240
|
+
const manifestChanged = added.length > 0 || removed.length > 0 || (paletteBytes === null) !== (previousPalette === null);
|
|
241
|
+
return {result, extensionSave, added, removed, palette, paletteBytes, paletteChanged, manifestChanged};
|
|
225
242
|
};
|
|
226
243
|
// The explorer's tree from the folder's screen state. It can arrive before or after the folder is current.
|
|
227
244
|
let expectingTree = false;
|
|
@@ -357,10 +374,11 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
|
|
|
357
374
|
const paths = new Set<string>();
|
|
358
375
|
if (!current) return paths;
|
|
359
376
|
try {
|
|
360
|
-
const {result, extensionSave, added, removed} = planSave(current, snapshot());
|
|
377
|
+
const {result, extensionSave, added, removed, paletteChanged, manifestChanged} = planSave(current, snapshot());
|
|
361
378
|
if (result) paths.add(projectFile);
|
|
362
379
|
if (extensionSave.manifestChanged) paths.add(extensionsFile);
|
|
363
|
-
if (
|
|
380
|
+
if (manifestChanged) paths.add(manifestFile);
|
|
381
|
+
if (paletteChanged) paths.add(paletteFile);
|
|
364
382
|
for (const name of [...added.map(([name]) => name), ...removed]) paths.add(`assets/${name}`);
|
|
365
383
|
for (const name of [...extensionSave.writes.keys(), ...extensionSave.removed]) paths.add(`extensions/${name}`);
|
|
366
384
|
} catch (error) {
|
|
@@ -373,11 +391,13 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
|
|
|
373
391
|
readUnsavedFile(path: string): Uint8Array | null | undefined {
|
|
374
392
|
if (!current || busy) return;
|
|
375
393
|
try {
|
|
376
|
-
const {result, extensionSave, added, removed
|
|
394
|
+
const {result, extensionSave, added, removed, paletteBytes, paletteChanged, manifestChanged} =
|
|
395
|
+
planSave(current, snapshot());
|
|
377
396
|
if (path === projectFile && result) return encodeJson(extensionSave.project);
|
|
378
397
|
if (path === extensionsFile && extensionSave.manifestChanged) return encodeJson(extensionSave.embedded);
|
|
379
|
-
if (path === manifestFile &&
|
|
380
|
-
return saveManifest(current.source, added.map(([name]) => name), removed);
|
|
398
|
+
if (path === manifestFile && manifestChanged)
|
|
399
|
+
return saveManifest(current.source, added.map(([name]) => name), removed, paletteBytes !== null);
|
|
400
|
+
if (path === paletteFile && paletteChanged) return paletteBytes;
|
|
381
401
|
if (path.startsWith('assets/')) {
|
|
382
402
|
const name = path.slice('assets/'.length);
|
|
383
403
|
if (removed.includes(name)) return null;
|
|
@@ -436,9 +456,8 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
|
|
|
436
456
|
const base = decoder.decode(session.source.files.get(projectFile));
|
|
437
457
|
let editor: string | null;
|
|
438
458
|
try {
|
|
439
|
-
const
|
|
440
|
-
|
|
441
|
-
editor = result ? `${JSON.stringify(planExtensionSave(session.source, result).project, null, 2)}\n` : base;
|
|
459
|
+
const {result, extensionSave} = planSave(session, snapshot());
|
|
460
|
+
editor = result ? `${JSON.stringify(extensionSave.project, null, 2)}\n` : base;
|
|
442
461
|
} catch (error) {
|
|
443
462
|
if (!(error instanceof FolderError)) throw error;
|
|
444
463
|
editor = null;
|
|
@@ -552,7 +571,8 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
|
|
|
552
571
|
const saveRevision = revision;
|
|
553
572
|
const edited = snapshot();
|
|
554
573
|
const ids = identify(edited);
|
|
555
|
-
const {result, extensionSave, added: newAssets, removed
|
|
574
|
+
const {result, extensionSave, added: newAssets, removed, palette, paletteBytes, paletteChanged, manifestChanged} =
|
|
575
|
+
planSave(session, edited);
|
|
556
576
|
await assertFolderUnchanged(session.source);
|
|
557
577
|
active(session);
|
|
558
578
|
const {source} = session;
|
|
@@ -565,13 +585,13 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
|
|
|
565
585
|
if (asset.assetId !== id) return unsupported(`Asset hash mismatch: ${name}`);
|
|
566
586
|
added.set(name, data);
|
|
567
587
|
}
|
|
568
|
-
if (!result && !removed.length && !extensionSave.removed.length) {
|
|
588
|
+
if (!result && !removed.length && !extensionSave.removed.length && !paletteChanged && !manifestChanged) {
|
|
569
589
|
await saveScreenState(source.directory);
|
|
570
590
|
if (revision === saveRevision) host.onSaved();
|
|
571
591
|
notify();
|
|
572
592
|
return {status: 'unchanged', sourceRemoved: []};
|
|
573
593
|
}
|
|
574
|
-
const manifest =
|
|
594
|
+
const manifest = manifestChanged ? saveManifest(source, added.keys(), removed, paletteBytes !== null) : null;
|
|
575
595
|
const root = {directory: source.directory, files: source.files, prefix: ''};
|
|
576
596
|
const assets = {directory: await source.directory.getDirectoryHandle('assets', {create: true}), files: source.bytes, prefix: 'assets/'};
|
|
577
597
|
const extensions = {directory: await source.directory.getDirectoryHandle('extensions', {create: true}),
|
|
@@ -626,6 +646,7 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
|
|
|
626
646
|
try {
|
|
627
647
|
for (const [name, data] of added) await write(assets, name, data);
|
|
628
648
|
for (const [name, data] of extensionSave.writes) await write(extensions, name, data);
|
|
649
|
+
if (paletteBytes && paletteChanged) await write(root, paletteFile, paletteBytes);
|
|
629
650
|
if (manifest) await write(root, manifestFile, manifest);
|
|
630
651
|
if (extensionSave.manifestChanged) {
|
|
631
652
|
await write(root, extensionsFile, encodeJson(extensionSave.embedded));
|
|
@@ -637,7 +658,10 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
|
|
|
637
658
|
}
|
|
638
659
|
source.project = extensionSave.project;
|
|
639
660
|
source.embedded = extensionSave.embedded;
|
|
640
|
-
|
|
661
|
+
source.palette = palette;
|
|
662
|
+
const removedRoot = paletteBytes === null && paletteChanged ? [paletteFile] : [];
|
|
663
|
+
for (const [{directory, files, prefix}, names] of
|
|
664
|
+
[[root, removedRoot], [assets, removed], [extensions, extensionSave.removed]] as const) {
|
|
641
665
|
for (const name of names) {
|
|
642
666
|
try {
|
|
643
667
|
const file = await (await directory.getFileHandle(name)).getFile();
|
package/src/source.ts
CHANGED
|
@@ -1,3 +1,7 @@
|
|
|
1
|
+
import {applyBlockPaletteComments, blockPaletteFile, extractBlockPalette, resolveBlockPaletteReferences,
|
|
2
|
+
serializeBlockPaletteDocument, validateBlockPaletteDocument} from '@kubohiroya/sb3-toolchain/browser';
|
|
3
|
+
import type {BlockPaletteDocument} from '@kubohiroya/sb3-toolchain/browser';
|
|
4
|
+
|
|
1
5
|
export type Json = null | boolean | number | string | Json[] | {[key: string]: Json};
|
|
2
6
|
export type JsonObject = {[key: string]: Json};
|
|
3
7
|
export type Project = JsonObject & {targets: Target[]};
|
|
@@ -6,6 +10,10 @@ type Target = JsonObject & {isStage: boolean; name: string};
|
|
|
6
10
|
export const projectFile = 'project.source.json';
|
|
7
11
|
export const manifestFile = 'sb3-source.json';
|
|
8
12
|
export const extensionsFile = 'embedded-extensions.json';
|
|
13
|
+
/** The ZIP entry of the Editor's screen state, which sb3-toolchain lists in `archiveEntries`. */
|
|
14
|
+
const screenStateEntry = 'tw-plus/workspace.json';
|
|
15
|
+
/** Block palette settings of source format 2. Format 1 folders have no such file. */
|
|
16
|
+
export const paletteFile = blockPaletteFile;
|
|
9
17
|
const embeddedReference = 'embedded-extension:';
|
|
10
18
|
|
|
11
19
|
export class FolderError extends Error {
|
|
@@ -65,8 +73,38 @@ export type FolderSource = FolderFiles & {
|
|
|
65
73
|
loadText: string;
|
|
66
74
|
storageAssets: Map<string, Asset>;
|
|
67
75
|
embedded: ExtensionManifest;
|
|
76
|
+
/** The folder's `block-palette.json`, or null for a format 1 folder. */
|
|
77
|
+
palette: BlockPaletteDocument | null;
|
|
68
78
|
};
|
|
69
79
|
|
|
80
|
+
// The toolchain reports a broken palette with a plain Error; the Editor treats it as an unsupported folder.
|
|
81
|
+
const palette = <T>(action: () => T): T => {
|
|
82
|
+
try {
|
|
83
|
+
return action();
|
|
84
|
+
} catch (error) {
|
|
85
|
+
if (error instanceof FolderError) throw error;
|
|
86
|
+
return unsupported(`Invalid block palette settings: ${error instanceof Error ? error.message : String(error)}`);
|
|
87
|
+
}
|
|
88
|
+
};
|
|
89
|
+
type ToolchainProject = Parameters<typeof extractBlockPalette>[0];
|
|
90
|
+
/** A copy of a folder project with each palette reference turned back into its comment text, as the VM loads it. */
|
|
91
|
+
export const expandPalette = (project: Project, document: BlockPaletteDocument | null): Project => {
|
|
92
|
+
if (!document) return project;
|
|
93
|
+
const copy = structuredClone(project);
|
|
94
|
+
palette(() => applyBlockPaletteComments(copy as ToolchainProject, document));
|
|
95
|
+
return copy;
|
|
96
|
+
};
|
|
97
|
+
/**
|
|
98
|
+
* Moves palette comments from a project in the Editor's form into `block-palette.json` and returns the folder form
|
|
99
|
+
* of the project with the document, or a null document when no sprite or the stage has palette settings.
|
|
100
|
+
*/
|
|
101
|
+
export const collapsePalette = (project: Project): {project: Project; document: BlockPaletteDocument | null} => {
|
|
102
|
+
const copy = structuredClone(project);
|
|
103
|
+
const {document} = palette(() => extractBlockPalette(copy as ToolchainProject));
|
|
104
|
+
return {project: copy, document};
|
|
105
|
+
};
|
|
106
|
+
export const encodePalette = (document: BlockPaletteDocument) => new TextEncoder().encode(serializeBlockPaletteDocument(document));
|
|
107
|
+
|
|
70
108
|
const getFile = async (dir: FileSystemDirectoryHandle | null, name: string) =>
|
|
71
109
|
dir ? (await dir.getFileHandle(name)).getFile() : unsupported(`Missing folder for ${name}`);
|
|
72
110
|
export const fileVersion = (file: File) => `${file.size}:${file.lastModified}`;
|
|
@@ -286,15 +324,28 @@ export async function readFolder(directory: FileSystemDirectoryHandle, storage:
|
|
|
286
324
|
const project = parseProject(projectText);
|
|
287
325
|
const manifest = readObject(decoder.decode(files.get(manifestFile)));
|
|
288
326
|
const embedded = readObject(decoder.decode(files.get(extensionsFile)));
|
|
289
|
-
|
|
290
|
-
|
|
291
|
-
|
|
327
|
+
// Format 2 adds block-palette.json, and only a folder with palette settings uses it.
|
|
328
|
+
const formatVersion = manifest.formatVersion;
|
|
329
|
+
if ((formatVersion !== 1 && formatVersion !== 2) || manifest.project !== projectFile ||
|
|
330
|
+
manifest.embeddedExtensions !== extensionsFile || manifest.assetsDirectory !== 'assets' ||
|
|
331
|
+
!Array.isArray(manifest.archiveEntries) ||
|
|
332
|
+
(formatVersion === 1 ? manifest.blockPalette !== undefined : manifest.blockPalette !== paletteFile)) {
|
|
333
|
+
return unsupported('Expected an sb3-toolchain v1 or v2 folder');
|
|
334
|
+
}
|
|
335
|
+
let paletteDocument: BlockPaletteDocument | null = null;
|
|
336
|
+
if (formatVersion === 2) {
|
|
337
|
+
const [, paletteBytes] = await readEntry(directory, paletteFile);
|
|
338
|
+
files.set(paletteFile, paletteBytes);
|
|
339
|
+
paletteDocument = palette(() => validateBlockPaletteDocument(readObject(decoder.decode(paletteBytes))));
|
|
292
340
|
}
|
|
341
|
+
palette(() => resolveBlockPaletteReferences(project as ToolchainProject, paletteDocument));
|
|
293
342
|
if (project.turboWarpPlus !== undefined) return unsupported('Plus extension manifests are not supported in project folders');
|
|
294
343
|
const extensionManifest = validateExtensions(project, embedded);
|
|
295
344
|
const references = projectAssets(project);
|
|
296
345
|
const expected = new Set(['project.json', ...references.keys()]);
|
|
297
|
-
|
|
346
|
+
// sb3-toolchain lists the Editor's screen state among the entries; the file itself is not an asset.
|
|
347
|
+
const listed = (manifest.archiveEntries as string[]).filter(name => name !== screenStateEntry);
|
|
348
|
+
if (listed.length !== expected.size || !sameNames(new Set(listed), expected)) {
|
|
298
349
|
return unsupported('Asset references and archiveEntries do not match');
|
|
299
350
|
}
|
|
300
351
|
expected.delete('project.json');
|
|
@@ -305,11 +356,12 @@ export async function readFolder(directory: FileSystemDirectoryHandle, storage:
|
|
|
305
356
|
}
|
|
306
357
|
const bytes = new Map(await Promise.all([...expected].map(name => readEntry(assets, name, 'assets/'))));
|
|
307
358
|
const extensionBytes = new Map(await Promise.all(scripts.map(name => readEntry(extensions, name, 'extensions/'))));
|
|
308
|
-
const
|
|
359
|
+
const loaded = expandPalette(project, paletteDocument);
|
|
360
|
+
const loadText = extensionManifest.extensions.length ? JSON.stringify({...loaded, extensionURLs: {
|
|
309
361
|
...extensionURLs(project),
|
|
310
362
|
...Object.fromEntries(extensionManifest.extensions.map(entry =>
|
|
311
363
|
[entry.id, encodeDataUrl(entry, extensionBytes.get(`${entry.id}.js`)!)]))
|
|
312
|
-
}}) : projectText;
|
|
364
|
+
}}) : paletteDocument ? JSON.stringify(loaded) : projectText;
|
|
313
365
|
const storageAssets = new Map<string, Asset>();
|
|
314
366
|
for (const [name, kind] of references) {
|
|
315
367
|
const [id, format] = name.split('.');
|
|
@@ -318,7 +370,8 @@ export async function readFolder(directory: FileSystemDirectoryHandle, storage:
|
|
|
318
370
|
if (asset.assetId !== id) return unsupported(`Asset hash mismatch: ${name}`);
|
|
319
371
|
storageAssets.set(assetKey(type, id, format), asset);
|
|
320
372
|
}
|
|
321
|
-
return {versions, files, directory, bytes, extensionBytes, project, loadText, storageAssets, embedded: extensionManifest
|
|
373
|
+
return {versions, files, directory, bytes, extensionBytes, project, loadText, storageAssets, embedded: extensionManifest,
|
|
374
|
+
palette: paletteDocument};
|
|
322
375
|
}
|
|
323
376
|
|
|
324
377
|
export const sameBytes = (a: Uint8Array, b: Uint8Array) => a.length === b.length && a.every((value, index) => value === b[index]);
|
|
@@ -337,7 +390,8 @@ export async function readFolderUpdate(source: FolderSource, previous: FolderUpd
|
|
|
337
390
|
const [assetNames, extensionNames] = await Promise.all([readNames(assets), readNames(extensions)]);
|
|
338
391
|
if (!sameNames(assetNames, source.bytes.keys()) || !sameNames(extensionNames, source.extensionBytes.keys())) return 'structure';
|
|
339
392
|
const unchanged = await Promise.all([
|
|
340
|
-
...[manifestFile, extensionsFile
|
|
393
|
+
...[manifestFile, extensionsFile, ...source.files.has(paletteFile) ? [paletteFile] : []]
|
|
394
|
+
.map(async name => fileVersion(await getFile(directory, name)) === versions.get(name)),
|
|
341
395
|
...[...assetNames].map(async name => fileVersion(await getFile(assets, name)) === versions.get(`assets/${name}`)),
|
|
342
396
|
...[...extensionNames].map(async name => fileVersion(await getFile(extensions, name)) === versions.get(`extensions/${name}`))
|
|
343
397
|
]);
|