@kubohiroya/turbowarp-plus-editor-project-folder 0.10.0 → 0.11.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 +10 -2
- package/README.md +10 -2
- 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-BKa_B85G.js} +1 -1
- package/dist/{shared-zlHgCKDG.js → shared-tZS90T71.js} +380 -47
- package/dist/source.d.ts +16 -0
- package/package.json +2 -2
- package/src/create-folder.ts +12 -2
- package/src/explorer.tsx +4 -0
- package/src/session.ts +43 -19
- package/src/source.ts +57 -7
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,8 @@ 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
|
+
/** Block palette settings of source format 2. Format 1 folders have no such file. */
|
|
14
|
+
export const paletteFile = blockPaletteFile;
|
|
9
15
|
const embeddedReference = 'embedded-extension:';
|
|
10
16
|
|
|
11
17
|
export class FolderError extends Error {
|
|
@@ -65,8 +71,38 @@ export type FolderSource = FolderFiles & {
|
|
|
65
71
|
loadText: string;
|
|
66
72
|
storageAssets: Map<string, Asset>;
|
|
67
73
|
embedded: ExtensionManifest;
|
|
74
|
+
/** The folder's `block-palette.json`, or null for a format 1 folder. */
|
|
75
|
+
palette: BlockPaletteDocument | null;
|
|
68
76
|
};
|
|
69
77
|
|
|
78
|
+
// The toolchain reports a broken palette with a plain Error; the Editor treats it as an unsupported folder.
|
|
79
|
+
const palette = <T>(action: () => T): T => {
|
|
80
|
+
try {
|
|
81
|
+
return action();
|
|
82
|
+
} catch (error) {
|
|
83
|
+
if (error instanceof FolderError) throw error;
|
|
84
|
+
return unsupported(`Invalid block palette settings: ${error instanceof Error ? error.message : String(error)}`);
|
|
85
|
+
}
|
|
86
|
+
};
|
|
87
|
+
type ToolchainProject = Parameters<typeof extractBlockPalette>[0];
|
|
88
|
+
/** A copy of a folder project with each palette reference turned back into its comment text, as the VM loads it. */
|
|
89
|
+
export const expandPalette = (project: Project, document: BlockPaletteDocument | null): Project => {
|
|
90
|
+
if (!document) return project;
|
|
91
|
+
const copy = structuredClone(project);
|
|
92
|
+
palette(() => applyBlockPaletteComments(copy as ToolchainProject, document));
|
|
93
|
+
return copy;
|
|
94
|
+
};
|
|
95
|
+
/**
|
|
96
|
+
* Moves palette comments from a project in the Editor's form into `block-palette.json` and returns the folder form
|
|
97
|
+
* of the project with the document, or a null document when no sprite or the stage has palette settings.
|
|
98
|
+
*/
|
|
99
|
+
export const collapsePalette = (project: Project): {project: Project; document: BlockPaletteDocument | null} => {
|
|
100
|
+
const copy = structuredClone(project);
|
|
101
|
+
const {document} = palette(() => extractBlockPalette(copy as ToolchainProject));
|
|
102
|
+
return {project: copy, document};
|
|
103
|
+
};
|
|
104
|
+
export const encodePalette = (document: BlockPaletteDocument) => new TextEncoder().encode(serializeBlockPaletteDocument(document));
|
|
105
|
+
|
|
70
106
|
const getFile = async (dir: FileSystemDirectoryHandle | null, name: string) =>
|
|
71
107
|
dir ? (await dir.getFileHandle(name)).getFile() : unsupported(`Missing folder for ${name}`);
|
|
72
108
|
export const fileVersion = (file: File) => `${file.size}:${file.lastModified}`;
|
|
@@ -286,10 +322,21 @@ export async function readFolder(directory: FileSystemDirectoryHandle, storage:
|
|
|
286
322
|
const project = parseProject(projectText);
|
|
287
323
|
const manifest = readObject(decoder.decode(files.get(manifestFile)));
|
|
288
324
|
const embedded = readObject(decoder.decode(files.get(extensionsFile)));
|
|
289
|
-
|
|
290
|
-
|
|
291
|
-
|
|
325
|
+
// Format 2 adds block-palette.json, and only a folder with palette settings uses it.
|
|
326
|
+
const formatVersion = manifest.formatVersion;
|
|
327
|
+
if ((formatVersion !== 1 && formatVersion !== 2) || manifest.project !== projectFile ||
|
|
328
|
+
manifest.embeddedExtensions !== extensionsFile || manifest.assetsDirectory !== 'assets' ||
|
|
329
|
+
!Array.isArray(manifest.archiveEntries) ||
|
|
330
|
+
(formatVersion === 1 ? manifest.blockPalette !== undefined : manifest.blockPalette !== paletteFile)) {
|
|
331
|
+
return unsupported('Expected an sb3-toolchain v1 or v2 folder');
|
|
332
|
+
}
|
|
333
|
+
let paletteDocument: BlockPaletteDocument | null = null;
|
|
334
|
+
if (formatVersion === 2) {
|
|
335
|
+
const [, paletteBytes] = await readEntry(directory, paletteFile);
|
|
336
|
+
files.set(paletteFile, paletteBytes);
|
|
337
|
+
paletteDocument = palette(() => validateBlockPaletteDocument(readObject(decoder.decode(paletteBytes))));
|
|
292
338
|
}
|
|
339
|
+
palette(() => resolveBlockPaletteReferences(project as ToolchainProject, paletteDocument));
|
|
293
340
|
if (project.turboWarpPlus !== undefined) return unsupported('Plus extension manifests are not supported in project folders');
|
|
294
341
|
const extensionManifest = validateExtensions(project, embedded);
|
|
295
342
|
const references = projectAssets(project);
|
|
@@ -305,11 +352,12 @@ export async function readFolder(directory: FileSystemDirectoryHandle, storage:
|
|
|
305
352
|
}
|
|
306
353
|
const bytes = new Map(await Promise.all([...expected].map(name => readEntry(assets, name, 'assets/'))));
|
|
307
354
|
const extensionBytes = new Map(await Promise.all(scripts.map(name => readEntry(extensions, name, 'extensions/'))));
|
|
308
|
-
const
|
|
355
|
+
const loaded = expandPalette(project, paletteDocument);
|
|
356
|
+
const loadText = extensionManifest.extensions.length ? JSON.stringify({...loaded, extensionURLs: {
|
|
309
357
|
...extensionURLs(project),
|
|
310
358
|
...Object.fromEntries(extensionManifest.extensions.map(entry =>
|
|
311
359
|
[entry.id, encodeDataUrl(entry, extensionBytes.get(`${entry.id}.js`)!)]))
|
|
312
|
-
}}) : projectText;
|
|
360
|
+
}}) : paletteDocument ? JSON.stringify(loaded) : projectText;
|
|
313
361
|
const storageAssets = new Map<string, Asset>();
|
|
314
362
|
for (const [name, kind] of references) {
|
|
315
363
|
const [id, format] = name.split('.');
|
|
@@ -318,7 +366,8 @@ export async function readFolder(directory: FileSystemDirectoryHandle, storage:
|
|
|
318
366
|
if (asset.assetId !== id) return unsupported(`Asset hash mismatch: ${name}`);
|
|
319
367
|
storageAssets.set(assetKey(type, id, format), asset);
|
|
320
368
|
}
|
|
321
|
-
return {versions, files, directory, bytes, extensionBytes, project, loadText, storageAssets, embedded: extensionManifest
|
|
369
|
+
return {versions, files, directory, bytes, extensionBytes, project, loadText, storageAssets, embedded: extensionManifest,
|
|
370
|
+
palette: paletteDocument};
|
|
322
371
|
}
|
|
323
372
|
|
|
324
373
|
export const sameBytes = (a: Uint8Array, b: Uint8Array) => a.length === b.length && a.every((value, index) => value === b[index]);
|
|
@@ -337,7 +386,8 @@ export async function readFolderUpdate(source: FolderSource, previous: FolderUpd
|
|
|
337
386
|
const [assetNames, extensionNames] = await Promise.all([readNames(assets), readNames(extensions)]);
|
|
338
387
|
if (!sameNames(assetNames, source.bytes.keys()) || !sameNames(extensionNames, source.extensionBytes.keys())) return 'structure';
|
|
339
388
|
const unchanged = await Promise.all([
|
|
340
|
-
...[manifestFile, extensionsFile
|
|
389
|
+
...[manifestFile, extensionsFile, ...source.files.has(paletteFile) ? [paletteFile] : []]
|
|
390
|
+
.map(async name => fileVersion(await getFile(directory, name)) === versions.get(name)),
|
|
341
391
|
...[...assetNames].map(async name => fileVersion(await getFile(assets, name)) === versions.get(`assets/${name}`)),
|
|
342
392
|
...[...extensionNames].map(async name => fileVersion(await getFile(extensions, name)) === versions.get(`extensions/${name}`))
|
|
343
393
|
]);
|