@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.
- package/README.ja.md +12 -3
- package/README.md +12 -3
- package/dist/THIRD_PARTY_NOTICES.md +376 -0
- package/dist/explorer-state.d.ts +22 -0
- package/dist/explorer.js +29 -8
- package/dist/index.d.ts +3 -1
- package/dist/index.js +110 -24
- package/dist/session.d.ts +16 -0
- package/dist/{shared-BqC3-Bzi.js → shared-BKa_B85G.js} +1 -1
- package/dist/{shared-Dz9dzxQF.js → shared-tZS90T71.js} +412 -47
- package/dist/source.d.ts +16 -0
- package/package.json +2 -2
- package/src/create-folder.ts +12 -2
- package/src/explorer-files.ts +2 -1
- package/src/explorer-state.ts +50 -0
- package/src/explorer.tsx +27 -3
- package/src/index.ts +3 -1
- package/src/session.ts +122 -19
- package/src/source.ts +57 -7
|
@@ -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
|
|
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
|
-
|
|
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
|
|
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,
|
|
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';
|
|
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
|
-
|
|
96
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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
|
-
|
|
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 (
|
|
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
|
|
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 &&
|
|
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
|
|
363
|
-
|
|
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
|
|
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 =
|
|
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
|
-
|
|
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
|
-
|
|
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
|
]);
|