@kubohiroya/turbowarp-plus-editor-project-folder 0.9.3 → 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.
@@ -0,0 +1,50 @@
1
+ /**
2
+ * The expanded folders and the selected entry of each project folder's explorer, for this page. It outlives the
3
+ * explorer, which unmounts whenever the side panel shows another view, so the tree comes back as it was left, and
4
+ * the Editor's screen state reads it from here when a project is saved.
5
+ */
6
+
7
+ export interface ExplorerTreeState {
8
+ /** Folder paths relative to the project folder, such as `assets`. */
9
+ expanded: readonly string[];
10
+ /** The selected entry, a path relative to the project folder. */
11
+ selected?: string;
12
+ }
13
+
14
+ /** The folder the Editor keeps its own files in. The explorer and its search leave it out, like `.git`. */
15
+ export const editorDirectory = '.tw-plus';
16
+ /** The screen state of the Editor, inside `editorDirectory`. */
17
+ export const screenStateFile = 'workspace.json';
18
+ export const hiddenEntry = (name: string) => ['.git', editorDirectory].includes(name.toLowerCase());
19
+
20
+ const limit = 1000;
21
+ const states = new WeakMap<FileSystemDirectoryHandle, ExplorerTreeState>();
22
+ const listeners = new WeakMap<FileSystemDirectoryHandle, Set<(state: ExplorerTreeState) => void>>();
23
+
24
+ const validPath = (value: unknown): value is string => typeof value === 'string' && value.length > 0 &&
25
+ value.length <= 1024 && value.split('/').every(part => part && part !== '.' && part !== '..' && !hiddenEntry(part) &&
26
+ !/[\\\u0000]/u.test(part));
27
+
28
+ /** Read a tree state saved in a file, keeping only well-formed paths. */
29
+ export function parseExplorerState(value: unknown): ExplorerTreeState | undefined {
30
+ if (value === null || typeof value !== 'object' || Array.isArray(value)) return;
31
+ const {expanded, selected} = value as Record<string, unknown>;
32
+ if (!Array.isArray(expanded)) return;
33
+ return {expanded: [...new Set(expanded.filter(validPath))].slice(0, limit),
34
+ ...(validPath(selected) && {selected})};
35
+ }
36
+
37
+ export const readExplorerState = (directory: FileSystemDirectoryHandle) => states.get(directory);
38
+
39
+ /** Remember the tree of `directory`. With `notify`, a mounted explorer of that folder shows it too. */
40
+ export function writeExplorerState(directory: FileSystemDirectoryHandle, state: ExplorerTreeState, notify = false) {
41
+ states.set(directory, state);
42
+ if (notify) for (const listener of [...listeners.get(directory) ?? []]) listener(state);
43
+ }
44
+
45
+ export function subscribeExplorerState(directory: FileSystemDirectoryHandle, listener: (state: ExplorerTreeState) => void) {
46
+ let set = listeners.get(directory);
47
+ if (!set) listeners.set(directory, set = new Set());
48
+ set.add(listener);
49
+ return () => {set.delete(listener);};
50
+ }
package/src/explorer.tsx CHANGED
@@ -5,6 +5,8 @@ import {useTree} from '@headless-tree/react/react17';
5
5
  import {FolderError, isObject, manifestFile, projectFile} from './source.js';
6
6
  import {projectFolderOverwriteWarning} from './create-folder.js';
7
7
  import {followProjectFolder} from './folder-registry.js';
8
+ import {hiddenEntry, readExplorerState, subscribeExplorerState, writeExplorerState} from './explorer-state.js';
9
+ import type {ExplorerTreeState} from './explorer-state.js';
8
10
  import type {ExplorerMutation, FollowedFolder} from './folder-registry.js';
9
11
  import type {Json, Project} from './source.js';
10
12
  import {canMoveExplorerEntry, copyExplorerFile, createExplorerDirectory, deleteExplorerEntry, ExplorerFileError,
@@ -65,6 +67,7 @@ const messages = {
65
67
  unsaved: 'Unsaved changes', staged: 'Added to Git index',
66
68
  revisions: {committed: 'Committed', pushed: 'Pushed', merged: 'Pull request merged'},
67
69
  project: 'Project data', manifest: 'Folder manifest', extensions: 'Embedded extensions',
70
+ palette: 'Block palette settings',
68
71
  assetsDirectory: 'Costume and sound files', extensionsDirectory: 'Extension files',
69
72
  costume: (sprite: string, name: string) => `${sprite} · costume ${name}`,
70
73
  backdrop: (name: string) => `Stage · backdrop ${name}`,
@@ -84,6 +87,7 @@ const messages = {
84
87
  unsaved: '未保存の変更あり', staged: 'Git のインデックスに追加済み',
85
88
  revisions: {committed: 'コミット済み', pushed: 'プッシュ済み', merged: 'PR マージ済み'},
86
89
  project: '作品データ', manifest: '作品フォルダの目録', extensions: '埋め込み拡張の一覧',
90
+ palette: 'ブロックパレットの設定',
87
91
  assetsDirectory: 'コスチュームと音のファイル', extensionsDirectory: '拡張のファイル',
88
92
  costume: (sprite: string, name: string) => `${sprite} のコスチューム ${name}`,
89
93
  backdrop: (name: string) => `ステージの背景 ${name}`,
@@ -115,6 +119,8 @@ export function describeProjectFolder(project: Project, locale?: string, {manife
115
119
  [at(assetsDirectory), message.assetsDirectory],
116
120
  [at('extensions'), message.extensionsDirectory]
117
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);
118
124
  const users = new Map<string, string[]>();
119
125
  for (const target of Array.isArray(project.targets) ? project.targets : []) {
120
126
  if (!isObject(target)) continue;
@@ -327,7 +333,7 @@ function FileSearch({directory, query, locale, refreshKey, marks, fileStatuses,
327
333
  try {
328
334
  for await (const entry of (folder as IterableDirectory).values()) {
329
335
  if (!current) return;
330
- if (entry.name.toLowerCase() === '.git') continue;
336
+ if (hiddenEntry(entry.name)) continue;
331
337
  const path = base + entry.name;
332
338
  if (entry.kind === 'directory') await walk(entry as FileSystemDirectoryHandle, path + '/');
333
339
  else files.push({path, name: entry.name, kind: 'file'});
@@ -408,12 +414,23 @@ function Explorer({directory, locale, descriptions, marks, fileStatuses, unsaved
408
414
  return handle.getFile();
409
415
  };
410
416
  const deleted = React.useMemo(() => deletedChildren(deletedPaths(fileStatuses, marks)), [fileStatuses, marks]);
417
+ const [remembered] = React.useState(() => readExplorerState(directory));
418
+ const remember = (change: Partial<ExplorerTreeState>) => {
419
+ const previous = readExplorerState(directory) ?? {expanded: []};
420
+ const next = {...previous, ...change};
421
+ if (!next.selected) delete next.selected;
422
+ writeExplorerState(directory, next);
423
+ };
411
424
  const compareNodes = (a: ExplorerNode, b: ExplorerNode) =>
412
425
  (a.kind === 'directory' ? 0 : 1) - (b.kind === 'directory' ? 0 : 1) ||
413
426
  collator.compare(a.name, b.name) || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
414
427
  const tree = useTree<ExplorerNode>({
415
428
  rootItemId: rootId,
416
- initialState: {expandedItems: [], selectedItems: [], focusedItem: null},
429
+ // The tree comes back as it was left, or as the folder's screen state saved it.
430
+ initialState: {expandedItems: [...remembered?.expanded ?? []],
431
+ selectedItems: remembered?.selected ? [remembered.selected] : [], focusedItem: remembered?.selected ?? null},
432
+ setExpandedItems: expanded => remember({expanded: expanded as string[]}),
433
+ setSelectedItems: selected => remember({selected: (selected as string[])[0]}),
417
434
  getItemName: item => item.getItemData()?.name ?? '',
418
435
  isItemFolder: item => item.getItemData()?.kind === 'directory',
419
436
  createLoadingItemData: () => ({name: '', path: '', kind: 'file'}),
@@ -443,7 +460,7 @@ function Explorer({directory, locale, descriptions, marks, fileStatuses, unsaved
443
460
  try {
444
461
  const handle = await directoryAt(id);
445
462
  for await (const entry of (handle as IterableDirectory).values()) {
446
- if (entry.name.toLowerCase() === '.git') continue;
463
+ if (hiddenEntry(entry.name)) continue;
447
464
  const path = base + entry.name;
448
465
  if (entry.kind === 'directory') handles.set(path, entry as FileSystemDirectoryHandle);
449
466
  else files.set(path, entry as FileSystemFileHandle);
@@ -466,6 +483,13 @@ function Explorer({directory, locale, descriptions, marks, fileStatuses, unsaved
466
483
  tree.setMounted(true);
467
484
  return () => tree.setMounted(false);
468
485
  }, [tree]);
486
+ // A project opened again with this folder shows the tree its screen state saved.
487
+ React.useEffect(() => subscribeExplorerState(directory, state => {
488
+ tree.applySubStateUpdate('expandedItems', [...state.expanded]);
489
+ tree.applySubStateUpdate('selectedItems', state.selected ? [state.selected] : []);
490
+ tree.applySubStateUpdate('focusedItem', state.selected ?? null);
491
+ tree.rebuildTree();
492
+ }), [tree, directory]);
469
493
  const lastRefresh = React.useRef({refreshKey, deleted});
470
494
  React.useEffect(() => {
471
495
  const previous = lastRefresh.current;
package/src/index.ts CHANGED
@@ -4,7 +4,7 @@ import {isProjectFolderEmpty} from './create-folder.js';
4
4
  import {registerFolder} from './folder-registry.js';
5
5
  import type {FolderHost, FolderVM, PickerWindow} from './session.js';
6
6
 
7
- export type {Comparison, ComparisonRequest, ComparisonSection, FolderHost, FolderVM, OpenResult} from './session.js';
7
+ export type {Comparison, ComparisonRequest, ComparisonSection, FolderHost, FolderScreenState, FolderVM, OpenResult} from './session.js';
8
8
  export type {ReloadTarget} from './block-reload.js';
9
9
  export {followProjectFolder} from './folder-registry.js';
10
10
  export type {FollowedFolder} from './folder-registry.js';
@@ -333,3 +333,5 @@ export function renderProjectFolderMenu(createElement: MenuElement, {
333
333
  };
334
334
  return createElement(MenuSection, null, item('open'), entry.session.canSave ? item('save') : null);
335
335
  }
336
+ export {parseExplorerState, readExplorerState, subscribeExplorerState, writeExplorerState} from './explorer-state.js';
337
+ export type {ExplorerTreeState} from './explorer-state.js';
package/src/session.ts CHANGED
@@ -1,11 +1,64 @@
1
- import {assetKey, assetTypeFor, assertFolderUnchanged, extensionsFile, fileVersion, FolderError, manifestFile, parseProject,
2
- planExtensionSave, projectAssets, projectChanges, projectFile, readFolder, readFolderUpdate, sameBytes, unsupported} from './source.js';
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';
6
7
  import {applyScriptReload, planScriptReload} from './script-reload.js';
7
8
  import type {DeserializeBlocks, ScriptReloadTarget} from './script-reload.js';
8
9
  import {createProjectFolder} from './create-folder.js';
10
+ import {editorDirectory, parseExplorerState, readExplorerState, screenStateFile, writeExplorerState} from './explorer-state.js';
11
+ import type {ExplorerTreeState} from './explorer-state.js';
12
+
13
+ /**
14
+ * The Editor's screen state, such as `installProjectScreenState` of the workbench gives it. A project folder is not
15
+ * an SB3, so the folder keeps the state as `.tw-plus/workspace.json` and gives it back when it opens.
16
+ */
17
+ export interface FolderScreenState {
18
+ /** The text to write, or nothing to leave the file as it is. */
19
+ serialize(): string | undefined;
20
+ /** Use this text for the next project load. */
21
+ prepareLoad(text: string | undefined): void;
22
+ /** Add a slice, here the explorer's tree. Returns a function that removes it. */
23
+ register?(key: string, slice: {capture(): unknown; apply?(value: unknown): void}): () => void;
24
+ }
25
+
26
+ const screenStateMaxBytes = 512 * 1024;
27
+ const notFound = (error: unknown) => error instanceof DOMException && ['NotFoundError', 'TypeMismatchError'].includes(error.name);
28
+
29
+ /** The screen state the folder was saved with, or nothing. */
30
+ async function readScreenStateText(directory: FileSystemDirectoryHandle) {
31
+ try {
32
+ const file = await (await (await directory.getDirectoryHandle(editorDirectory)).getFileHandle(screenStateFile)).getFile();
33
+ return file.size > screenStateMaxBytes ? undefined : await file.text();
34
+ } catch (error) {
35
+ if (!notFound(error)) console.warn('The screen state of the project folder could not be read', error);
36
+ }
37
+ }
38
+
39
+ /** The slices of a screen state, to tell whether only the time of the save changed. */
40
+ const slicesOf = (text: string | undefined) => {
41
+ try { return JSON.stringify(JSON.parse(text!).slices); } catch { return undefined; }
42
+ };
43
+
44
+ /** Write the screen state next to the project. Failing to write it never fails the save. */
45
+ async function writeScreenStateText(directory: FileSystemDirectoryHandle, text: string) {
46
+ try {
47
+ if (slicesOf(await readScreenStateText(directory)) === slicesOf(text)) return;
48
+ const handle = await (await directory.getDirectoryHandle(editorDirectory, {create: true}))
49
+ .getFileHandle(screenStateFile, {create: true});
50
+ const writable = await handle.createWritable();
51
+ try {
52
+ await writable.write(new TextEncoder().encode(text));
53
+ await writable.close();
54
+ } catch (error) {
55
+ await writable.abort().catch(() => {});
56
+ throw error;
57
+ }
58
+ } catch (error) {
59
+ console.warn('The screen state of the project folder could not be saved', error);
60
+ }
61
+ }
9
62
 
10
63
  export interface FolderVM {
11
64
  runtime: {
@@ -61,6 +114,7 @@ export interface FolderHost {
61
114
  */
62
115
  compareChanges?(request: ComparisonRequest): Promise<string | null>;
63
116
  };
117
+ screenState?: FolderScreenState;
64
118
  }
65
119
 
66
120
  /** A titled comparison of two project.source.json texts; `null` stands for a version that cannot be shown. */
@@ -92,10 +146,13 @@ type SaveDirectory = {directory: FileSystemDirectoryHandle; files: Map<string, U
92
146
  type VMAsset = {assetId: string; dataFormat: string; data?: Uint8Array};
93
147
  const encodeJson = (value: unknown) => new TextEncoder().encode(`${JSON.stringify(value, null, 2)}\n`);
94
148
 
95
- function saveManifest(source: FolderSource, added: Iterable<string>, removed: readonly string[]) {
96
- const value = JSON.parse(new TextDecoder().decode(source.files.get(manifestFile))) as JsonObject;
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;
97
152
  const entries = (value.archiveEntries as string[]).filter(name => !removed.includes(name));
98
- return encodeJson({...value, archiveEntries: [...entries, ...added]});
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} : {}});
99
156
  }
100
157
 
101
158
  export function createFolderSession(vm: FolderVM, host: FolderHost) {
@@ -163,12 +220,41 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
163
220
  const changed = () => {revision++; notifyEdits();};
164
221
  const planSave = (session: Session, edited: Project) => {
165
222
  const {source} = session;
166
- const result = projectChanges(source.project, session.baseline, edited, identity(session, edited));
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);
167
235
  const extensionSave = planExtensionSave(source, result ?? source.project);
168
236
  const needed = projectAssets(extensionSave.project);
169
237
  const added = [...needed].filter(([name]) => !source.bytes.has(name));
170
238
  const removed = [...source.bytes.keys()].filter(name => !needed.has(name));
171
- return {result, extensionSave, added, removed};
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};
242
+ };
243
+ // The explorer's tree from the folder's screen state. It can arrive before or after the folder is current.
244
+ let expectingTree = false;
245
+ let pendingTree: ExplorerTreeState | undefined;
246
+ const unregisterTree = host.screenState?.register?.('projectFolder', {
247
+ capture: () => current ? readExplorerState(current.source.directory) : undefined,
248
+ apply(value) {
249
+ const tree = parseExplorerState(value);
250
+ if (!tree) return;
251
+ if (current) writeExplorerState(current.source.directory, tree, true);
252
+ else if (expectingTree) pendingTree = tree;
253
+ }
254
+ });
255
+ const saveScreenState = async (directory: FileSystemDirectoryHandle) => {
256
+ const text = host.screenState?.serialize();
257
+ if (text !== undefined) await writeScreenStateText(directory, text);
172
258
  };
173
259
  const loaded = () => setCurrent(null);
174
260
  vm.runtime.on('PROJECT_LOADED', loaded);
@@ -185,6 +271,7 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
185
271
  editListeners.clear();
186
272
  vm.runtime.off('PROJECT_LOADED', loaded);
187
273
  vm.off('PROJECT_CHANGED', changed);
274
+ unregisterTree?.();
188
275
  };
189
276
  const openFrom = async (
190
277
  getDirectory: () => Promise<FileSystemDirectoryHandle | null>,
@@ -209,7 +296,10 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
209
296
  const assets = source.storageAssets;
210
297
  reader.assets = assets;
211
298
  let stage: object | null;
299
+ pendingTree = undefined;
300
+ expectingTree = true;
212
301
  try {
302
+ if (host.screenState) host.screenState.prepareLoad(await readScreenStateText(directory));
213
303
  vm.quit();
214
304
  await vm.loadProject(source.loadText, {replaceLegacyExtensions: true});
215
305
  stage = vm.runtime.getTargetForStage();
@@ -220,6 +310,10 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
220
310
  host.onOpened(directory.name);
221
311
  const baseline = snapshot();
222
312
  setCurrent({source, stage, baseline, ids: identify(baseline), pending: null});
313
+ // The tree may come with the load or right after it; once the folder is current, it is written there.
314
+ expectingTree = false;
315
+ if (pendingTree) writeExplorerState(directory, pendingTree, true);
316
+ pendingTree = undefined;
223
317
  vm.renderer?.draw();
224
318
  return 'opened';
225
319
  } finally {
@@ -280,10 +374,11 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
280
374
  const paths = new Set<string>();
281
375
  if (!current) return paths;
282
376
  try {
283
- const {result, extensionSave, added, removed} = planSave(current, snapshot());
377
+ const {result, extensionSave, added, removed, paletteChanged, manifestChanged} = planSave(current, snapshot());
284
378
  if (result) paths.add(projectFile);
285
379
  if (extensionSave.manifestChanged) paths.add(extensionsFile);
286
- if (added.length || removed.length) paths.add(manifestFile);
380
+ if (manifestChanged) paths.add(manifestFile);
381
+ if (paletteChanged) paths.add(paletteFile);
287
382
  for (const name of [...added.map(([name]) => name), ...removed]) paths.add(`assets/${name}`);
288
383
  for (const name of [...extensionSave.writes.keys(), ...extensionSave.removed]) paths.add(`extensions/${name}`);
289
384
  } catch (error) {
@@ -296,11 +391,13 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
296
391
  readUnsavedFile(path: string): Uint8Array | null | undefined {
297
392
  if (!current || busy) return;
298
393
  try {
299
- const {result, extensionSave, added, removed} = planSave(current, snapshot());
394
+ const {result, extensionSave, added, removed, paletteBytes, paletteChanged, manifestChanged} =
395
+ planSave(current, snapshot());
300
396
  if (path === projectFile && result) return encodeJson(extensionSave.project);
301
397
  if (path === extensionsFile && extensionSave.manifestChanged) return encodeJson(extensionSave.embedded);
302
- if (path === manifestFile && (added.length || removed.length))
303
- 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;
304
401
  if (path.startsWith('assets/')) {
305
402
  const name = path.slice('assets/'.length);
306
403
  if (removed.includes(name)) return null;
@@ -359,9 +456,8 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
359
456
  const base = decoder.decode(session.source.files.get(projectFile));
360
457
  let editor: string | null;
361
458
  try {
362
- const edited = snapshot();
363
- const result = projectChanges(session.source.project, session.baseline, edited, identity(session, edited));
364
- 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;
365
461
  } catch (error) {
366
462
  if (!(error instanceof FolderError)) throw error;
367
463
  editor = null;
@@ -475,7 +571,8 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
475
571
  const saveRevision = revision;
476
572
  const edited = snapshot();
477
573
  const ids = identify(edited);
478
- const {result, extensionSave, added: newAssets, removed} = planSave(session, edited);
574
+ const {result, extensionSave, added: newAssets, removed, palette, paletteBytes, paletteChanged, manifestChanged} =
575
+ planSave(session, edited);
479
576
  await assertFolderUnchanged(session.source);
480
577
  active(session);
481
578
  const {source} = session;
@@ -488,12 +585,13 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
488
585
  if (asset.assetId !== id) return unsupported(`Asset hash mismatch: ${name}`);
489
586
  added.set(name, data);
490
587
  }
491
- if (!result && !removed.length && !extensionSave.removed.length) {
588
+ if (!result && !removed.length && !extensionSave.removed.length && !paletteChanged && !manifestChanged) {
589
+ await saveScreenState(source.directory);
492
590
  if (revision === saveRevision) host.onSaved();
493
591
  notify();
494
592
  return {status: 'unchanged', sourceRemoved: []};
495
593
  }
496
- const manifest = added.size || removed.length ? saveManifest(source, added.keys(), removed) : null;
594
+ const manifest = manifestChanged ? saveManifest(source, added.keys(), removed, paletteBytes !== null) : null;
497
595
  const root = {directory: source.directory, files: source.files, prefix: ''};
498
596
  const assets = {directory: await source.directory.getDirectoryHandle('assets', {create: true}), files: source.bytes, prefix: 'assets/'};
499
597
  const extensions = {directory: await source.directory.getDirectoryHandle('extensions', {create: true}),
@@ -548,6 +646,7 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
548
646
  try {
549
647
  for (const [name, data] of added) await write(assets, name, data);
550
648
  for (const [name, data] of extensionSave.writes) await write(extensions, name, data);
649
+ if (paletteBytes && paletteChanged) await write(root, paletteFile, paletteBytes);
551
650
  if (manifest) await write(root, manifestFile, manifest);
552
651
  if (extensionSave.manifestChanged) {
553
652
  await write(root, extensionsFile, encodeJson(extensionSave.embedded));
@@ -559,7 +658,10 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
559
658
  }
560
659
  source.project = extensionSave.project;
561
660
  source.embedded = extensionSave.embedded;
562
- for (const [{directory, files, prefix}, names] of [[assets, removed], [extensions, extensionSave.removed]] as const) {
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) {
563
665
  for (const name of names) {
564
666
  try {
565
667
  const file = await (await directory.getFileHandle(name)).getFile();
@@ -576,6 +678,7 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
576
678
  session.baseline = edited;
577
679
  session.ids = ids;
578
680
  session.pending = null;
681
+ await saveScreenState(source.directory);
579
682
  if (current === session && revision === saveRevision) host.onSaved();
580
683
  notify();
581
684
  return {status: 'saved', sourceRemoved: extensionSave.sourceRemoved};
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
- if (manifest.formatVersion !== 1 || manifest.project !== projectFile || manifest.embeddedExtensions !== extensionsFile ||
290
- manifest.assetsDirectory !== 'assets' || !Array.isArray(manifest.archiveEntries)) {
291
- return unsupported('Expected an sb3-toolchain v1 folder');
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 loadText = extensionManifest.extensions.length ? JSON.stringify({...project, extensionURLs: {
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].map(async name => fileVersion(await getFile(directory, name)) === versions.get(name)),
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
  ]);