@kubohiroya/turbowarp-plus-editor-project-folder 0.8.0 → 0.9.1

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,134 @@
1
+ export interface FilePreviewRequest {
2
+ reference: {providerId: string; documentId: string};
3
+ filename: string;
4
+ title: string;
5
+ transient: true;
6
+ mount(element: HTMLElement, close: () => void): {requestClose(): void; dispose(): void};
7
+ }
8
+
9
+ export type FileBaseline = {branch: string | undefined; head: string | null; bytes: Uint8Array | null};
10
+ export type ReadFileBaseline = (directory: FileSystemDirectoryHandle, path: string, limit: number) =>
11
+ Promise<FileBaseline | null>;
12
+
13
+ const mimeTypes = new Map(Object.entries({
14
+ apng: 'image/apng', avif: 'image/avif', bmp: 'image/bmp', gif: 'image/gif', ico: 'image/x-icon',
15
+ jpg: 'image/jpeg', jpeg: 'image/jpeg', png: 'image/png', svg: 'image/svg+xml', webp: 'image/webp',
16
+ aac: 'audio/aac', aif: 'audio/aiff', aiff: 'audio/aiff', flac: 'audio/flac', m4a: 'audio/mp4',
17
+ mp3: 'audio/mpeg', oga: 'audio/ogg', ogg: 'audio/ogg', opus: 'audio/ogg', wav: 'audio/wav',
18
+ m4v: 'video/mp4', mov: 'video/quicktime', mp4: 'video/mp4', ogv: 'video/ogg', webm: 'video/webm'
19
+ }));
20
+ export const textLimit = 4 * 1024 * 1024;
21
+
22
+ const styles = `
23
+ .twpf-preview{box-sizing:border-box;height:100%;overflow:auto;padding:1rem;color:var(--text-primary,inherit);
24
+ background:var(--ui-primary,transparent)}
25
+ .twpf-preview:has(.twpf-text-file){padding:0;overflow:hidden}
26
+ .twpf-preview img,.twpf-preview video{display:block;max-width:100%;max-height:100%;margin:auto;object-fit:contain}
27
+ .twpf-preview audio{width:min(100%,32rem)}
28
+ `;
29
+
30
+ const messages = {
31
+ en: {
32
+ loading: 'Loading file…', failed: 'This file could not be read.',
33
+ unsupported: 'This file cannot be previewed.', mediaError: 'This media could not be opened.',
34
+ large: 'This text file is too large to open (4 MiB limit).'
35
+ },
36
+ ja: {
37
+ loading: 'ファイルを読み込んでいます…', failed: 'このファイルを読み込めません。',
38
+ unsupported: 'このファイルはプレビューできません。', mediaError: 'このメディアを開けません。',
39
+ large: 'このテキストファイルは開けるサイズの上限(4 MiB)を超えています。'
40
+ }
41
+ };
42
+
43
+ async function fileAt(directory: FileSystemDirectoryHandle, path: string): Promise<FileSystemFileHandle> {
44
+ const parts = path.split('/');
45
+ const name = parts.pop()!;
46
+ for (const part of parts) directory = await directory.getDirectoryHandle(part);
47
+ return directory.getFileHandle(name);
48
+ }
49
+
50
+ export function createFilePreview(directory: FileSystemDirectoryHandle, documentId: string,
51
+ {name, path}: {name: string; path: string}, locale: string, readBaseline?: ReadFileBaseline): FilePreviewRequest {
52
+ return {
53
+ reference: {providerId: 'turbowarp-plus-project-folder', documentId},
54
+ filename: name,
55
+ title: name,
56
+ transient: true,
57
+ mount(element, close) {
58
+ const message = locale.toLowerCase().startsWith('ja') ? messages.ja : messages.en;
59
+ const {ownerDocument: document} = element;
60
+ const panel = document.createElement('div');
61
+ panel.className = 'twpf-preview';
62
+ const style = document.createElement('style');
63
+ style.textContent = styles;
64
+ const status = document.createElement('p');
65
+ status.setAttribute('role', 'status');
66
+ status.textContent = message.loading;
67
+ panel.append(style, status);
68
+ element.append(panel);
69
+ let disposed = false;
70
+ let url: string | undefined;
71
+ let media: HTMLMediaElement | undefined;
72
+ let textSession: ReturnType<FilePreviewRequest['mount']> | undefined;
73
+ const readHandle = () => fileAt(directory, path);
74
+
75
+ const show = (node: HTMLElement) => status.replaceWith(node);
76
+ const load = async () => {
77
+ const file = await (await readHandle()).getFile();
78
+ if (disposed) return;
79
+ const extension = name.includes('.') ? name.split('.').pop()!.toLowerCase() : '';
80
+ const mime = mimeTypes.get(extension) ?? file.type;
81
+ const kind = mime.split('/')[0];
82
+ if (kind === 'image' || kind === 'audio' || kind === 'video') {
83
+ url = URL.createObjectURL(mime === file.type ? file : file.slice(0, file.size, mime));
84
+ const view = document.createElement(kind === 'image' ? 'img' : kind);
85
+ view.addEventListener('error', () => {
86
+ status.textContent = message.mediaError;
87
+ view.replaceWith(status);
88
+ }, {once: true});
89
+ if (view.tagName === 'IMG') {
90
+ // An SVG loaded through an img cannot run scripts in the editor.
91
+ (view as HTMLImageElement).alt = name;
92
+ } else {
93
+ media = view as HTMLMediaElement;
94
+ media.controls = true;
95
+ media.preload = 'metadata';
96
+ media.setAttribute('aria-label', name);
97
+ }
98
+ view.src = url;
99
+ show(view);
100
+ return;
101
+ }
102
+ if (file.size > textLimit) {
103
+ status.textContent = message.large;
104
+ return;
105
+ }
106
+ const [bytes, {decodeText, mountTextFile}] = await Promise.all([
107
+ file.arrayBuffer(), import('./text-file-editor.js')
108
+ ]);
109
+ if (disposed) return;
110
+ const content = decodeText(bytes);
111
+ if (content === null) {
112
+ status.textContent = message.unsupported;
113
+ return;
114
+ }
115
+ textSession = mountTextFile(panel, {
116
+ path, extension, content, locale, limit: textLimit, readHandle, close,
117
+ readBaseline: readBaseline && (() => readBaseline(directory, path, textLimit))
118
+ });
119
+ status.remove();
120
+ };
121
+ void load().catch(() => {if (!disposed) status.textContent = message.failed;});
122
+ return {
123
+ requestClose() {if (textSession) textSession.requestClose(); else close();},
124
+ dispose() {
125
+ disposed = true;
126
+ textSession?.dispose();
127
+ media?.pause();
128
+ if (url) URL.revokeObjectURL(url);
129
+ panel.remove();
130
+ }
131
+ };
132
+ }
133
+ };
134
+ }
@@ -1,9 +1,14 @@
1
1
  /** The project folder mounted for a VM, as a view of the folder follows it. */
2
+ export type ExplorerMutation = (guard: () => void) => Promise<void>;
3
+
2
4
  export interface FollowedFolder {
3
5
  readonly directory: FileSystemDirectoryHandle | null;
4
6
  subscribe(listener: () => void): () => void;
7
+ subscribeEdits(listener: () => void): () => void;
8
+ unsavedPaths(): ReadonlySet<string> | null;
5
9
  /** Asks for a folder and opens it, as the File menu's Open Project Folder… does. */
6
10
  open(locale: string): void;
11
+ mutate(directory: FileSystemDirectoryHandle, operation: ExplorerMutation): Promise<void>;
7
12
  }
8
13
  const folders = new WeakMap<object, FollowedFolder>();
9
14
  // Views rendered before the folder is mounted, or after it is disposed, wait for the VM's folder here.
package/src/index.ts CHANGED
@@ -8,6 +8,7 @@ export type {ReloadTarget} from './block-reload.js';
8
8
  export {followProjectFolder} from './folder-registry.js';
9
9
  export type {FollowedFolder} from './folder-registry.js';
10
10
  export type {DeserializeBlocks} from './script-reload.js';
11
+ export {createProjectFolder} from './create-folder.js';
11
12
 
12
13
  const messages = {
13
14
  en: {
@@ -235,7 +236,12 @@ export function mountProjectFolder({vm, document, host, locale = 'en', autoReloa
235
236
  save(locale) {
236
237
  if (!session.busy) {
237
238
  const message = messageFor(locale);
238
- void session.save().then(({status, sourceRemoved}) => {
239
+ const directory = session.directory;
240
+ const save = () => {
241
+ if (session.directory !== directory) throw new FolderError('conflict');
242
+ return session.save();
243
+ };
244
+ void (host.saveWithLock?.(save) ?? save()).then(({status, sourceRemoved}) => {
239
245
  const detail = sourceRemoved.length ? ` ${message.sourceRemoved(sourceRemoved)}` : '';
240
246
  report(message[status] + detail);
241
247
  }, error => fail(locale, error)).finally(renderReload);
@@ -247,11 +253,30 @@ export function mountProjectFolder({vm, document, host, locale = 'en', autoReloa
247
253
  const unregister = registerFolder(vm, {
248
254
  get directory() {return session.directory;},
249
255
  subscribe: listener => session.subscribe(listener),
250
- open: locale => menu.open(locale)
256
+ subscribeEdits: listener => session.subscribeEdits(listener),
257
+ unsavedPaths: () => session.unsavedPaths(),
258
+ open: locale => menu.open(locale),
259
+ mutate: (directory, operation) => session.mutate(directory, operation).finally(renderReload)
251
260
  });
252
261
  return {
253
262
  openDirectory: (...args: Parameters<typeof session.openDirectory>) =>
254
263
  session.openDirectory(...args).finally(renderReload),
264
+ save: () => session.save().finally(renderReload),
265
+ createFromSnapshot({prepareFiles, directory, current = () => true}: {
266
+ prepareFiles: () => Promise<ReadonlyMap<string, Uint8Array>>;
267
+ directory?: FileSystemDirectoryHandle;
268
+ current?: () => boolean;
269
+ }) {
270
+ return session.createFromSnapshot(async () => {
271
+ if (directory) return directory;
272
+ try {
273
+ return await pickDirectory.call(view, {id: 'turbowarp-plus-project-folder', mode: 'readwrite'});
274
+ } catch (error) {
275
+ if (error instanceof DOMException && error.name === 'AbortError') return null;
276
+ throw error;
277
+ }
278
+ }, prepareFiles, current).finally(renderReload);
279
+ },
255
280
  /**
256
281
  * The folder the loaded project came from, or `null` once another project loaded or the folder was
257
282
  * detached. A host can tell projects apart by it, for example to keep the layout of each one.
package/src/session.ts CHANGED
@@ -5,6 +5,7 @@ import {applyBlockReload, planBlockReload} from './block-reload.js';
5
5
  import type {ReloadTarget} from './block-reload.js';
6
6
  import {applyScriptReload, planScriptReload} from './script-reload.js';
7
7
  import type {DeserializeBlocks, ScriptReloadTarget} from './script-reload.js';
8
+ import {createProjectFolder} from './create-folder.js';
8
9
 
9
10
  export interface FolderVM {
10
11
  runtime: {
@@ -44,6 +45,7 @@ export interface FolderHost {
44
45
  beforeLoad(): void;
45
46
  onOpened(title: string): void;
46
47
  onSaved(): void;
48
+ saveWithLock?<T>(save: () => Promise<T>): Promise<T>;
47
49
  blockReload?: {
48
50
  isRunning(): boolean;
49
51
  subscribe(listener: () => void): () => void;
@@ -149,7 +151,18 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
149
151
  }
150
152
  return null;
151
153
  };
152
- const changed = () => {revision++;};
154
+ const editListeners = new Set<() => void>();
155
+ const notifyEdits = () => {for (const listener of [...editListeners]) listener();};
156
+ const changed = () => {revision++; notifyEdits();};
157
+ const planSave = (session: Session, edited: Project) => {
158
+ const {source} = session;
159
+ const result = projectChanges(source.project, session.baseline, edited, identity(session, edited));
160
+ const extensionSave = planExtensionSave(source, result ?? source.project);
161
+ const needed = projectAssets(extensionSave.project);
162
+ const added = [...needed].filter(([name]) => !source.bytes.has(name));
163
+ const removed = [...source.bytes.keys()].filter(name => !needed.has(name));
164
+ return {result, extensionSave, added, removed};
165
+ };
153
166
  const loaded = () => setCurrent(null);
154
167
  vm.runtime.on('PROJECT_LOADED', loaded);
155
168
  vm.on('PROJECT_CHANGED', changed);
@@ -162,12 +175,16 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
162
175
  disposed = true;
163
176
  setCurrent(null);
164
177
  listeners.clear();
178
+ editListeners.clear();
165
179
  vm.runtime.off('PROJECT_LOADED', loaded);
166
180
  vm.off('PROJECT_CHANGED', changed);
167
181
  };
168
182
  const openFrom = async (
169
183
  getDirectory: () => Promise<FileSystemDirectoryHandle | null>,
170
- confirmReplace: () => boolean
184
+ confirmReplace: () => boolean,
185
+ prepare: (directory: FileSystemDirectoryHandle) => Promise<FolderSource | null> =
186
+ directory => readFolder(directory, vm.runtime.storage),
187
+ stillCurrent = () => true
171
188
  ): Promise<OpenResult> => {
172
189
  if (disposed || busy) return 'cancelled';
173
190
  busy = true;
@@ -176,8 +193,8 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
176
193
  const directory = await getDirectory();
177
194
  if (!directory || disposed) return 'cancelled';
178
195
  const storage = vm.runtime.storage;
179
- const source = await readFolder(directory, storage);
180
- if (disposed || vm.runtime.getTargetForStage() !== priorStage) return 'cancelled';
196
+ const source = await prepare(directory);
197
+ if (!source || disposed || !stillCurrent() || vm.runtime.getTargetForStage() !== priorStage) return 'cancelled';
181
198
  if (host.isProjectDirty() && !confirmReplace()) return 'cancelled';
182
199
  host.beforeLoad();
183
200
  setCurrent(null);
@@ -246,6 +263,28 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
246
263
  listeners.add(listener);
247
264
  return () => {listeners.delete(listener);};
248
265
  },
266
+ subscribeEdits(listener: () => void) {
267
+ editListeners.add(listener);
268
+ return () => {editListeners.delete(listener);};
269
+ },
270
+ /** Files affected by the pending save. A save in progress still owns its baseline. */
271
+ unsavedPaths(): ReadonlySet<string> | null {
272
+ if (busy) return null;
273
+ const paths = new Set<string>();
274
+ if (!current) return paths;
275
+ try {
276
+ const {result, extensionSave, added, removed} = planSave(current, snapshot());
277
+ if (result) paths.add(projectFile);
278
+ if (extensionSave.manifestChanged) paths.add(extensionsFile);
279
+ if (added.length || removed.length) paths.add(manifestFile);
280
+ for (const name of [...added.map(([name]) => name), ...removed]) paths.add(`assets/${name}`);
281
+ for (const name of [...extensionSave.writes.keys(), ...extensionSave.removed]) paths.add(`extensions/${name}`);
282
+ } catch (error) {
283
+ if (!(error instanceof FolderError)) throw error;
284
+ if (host.isProjectDirty()) paths.add(projectFile);
285
+ }
286
+ return paths;
287
+ },
249
288
  get canSave() {return current !== null;},
250
289
  get busy() {return busy;},
251
290
  get reloadState() {return reloadState();},
@@ -266,6 +305,19 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
266
305
  return typeof pending === 'object' && pending !== null ? pending.update.version : null;
267
306
  },
268
307
  get directory() {return current?.source.directory ?? null;},
308
+ async mutate(directory: FileSystemDirectoryHandle, operation: (guard: () => void) => Promise<void>) {
309
+ const session = current;
310
+ if (!session || busy || session.source.directory !== directory) throw new FolderError('conflict');
311
+ const guard = () => active(session);
312
+ guard();
313
+ busy = true;
314
+ try {
315
+ await operation(guard);
316
+ } finally {
317
+ busy = false;
318
+ if (current === session) notify();
319
+ }
320
+ },
269
321
  /**
270
322
  * Reads what to compare before unsaved edits are replaced. `editor` is `null` when the edits cannot be
271
323
  * written to the folder, and `disk` when the folder's project file cannot be read.
@@ -334,9 +386,11 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
334
386
  session.source.versions.set(projectFile, pending.update.version);
335
387
  session.pending = null;
336
388
  host.blockReload.onApplied(targets);
389
+ notify();
337
390
  return true;
338
391
  } finally {
339
392
  busy = false;
393
+ notifyEdits();
340
394
  }
341
395
  },
342
396
  /**
@@ -363,6 +417,20 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
363
417
  openDirectory(directory: FileSystemDirectoryHandle, confirmReplace: () => boolean): Promise<OpenResult> {
364
418
  return openFrom(() => Promise.resolve(directory), confirmReplace);
365
419
  },
420
+ createFromSnapshot(getDirectory: () => Promise<FileSystemDirectoryHandle | null>,
421
+ prepareFiles: () => Promise<ReadonlyMap<string, Uint8Array>>, isCurrent: () => boolean): Promise<OpenResult> {
422
+ const stage = vm.runtime.getTargetForStage();
423
+ let savedRevision: number | undefined;
424
+ const currentProject = () => !disposed && vm.runtime.getTargetForStage() === stage &&
425
+ (savedRevision === undefined || revision === savedRevision) && isCurrent();
426
+ return openFrom(getDirectory, currentProject, async directory => {
427
+ if (!currentProject()) return null;
428
+ savedRevision = revision;
429
+ const files = await prepareFiles();
430
+ if (!currentProject()) return null;
431
+ return createProjectFolder({directory, files, storage: vm.runtime.storage, current: currentProject});
432
+ }, currentProject);
433
+ },
366
434
  async save(): Promise<SaveResult> {
367
435
  if (!current || busy) throw new FolderError('conflict');
368
436
  const session = current;
@@ -372,15 +440,12 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
372
440
  const saveRevision = revision;
373
441
  const edited = snapshot();
374
442
  const ids = identify(edited);
375
- const result = projectChanges(session.source.project, session.baseline, edited, identity(session, edited));
443
+ const {result, extensionSave, added: newAssets, removed} = planSave(session, edited);
376
444
  await assertFolderUnchanged(session.source);
377
445
  active(session);
378
446
  const {source} = session;
379
- const extensionSave = planExtensionSave(source, result ?? source.project);
380
- const needed = projectAssets(extensionSave.project);
381
447
  const added = new Map<string, Uint8Array>();
382
- for (const [name, kind] of needed) {
383
- if (source.bytes.has(name)) continue;
448
+ for (const [name, kind] of newAssets) {
384
449
  const data = assetData(name, kind);
385
450
  if (!data) return unsupported(`The data of ${name} is not in the Editor`);
386
451
  const [id, format] = name.split('.');
@@ -388,7 +453,6 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
388
453
  if (asset.assetId !== id) return unsupported(`Asset hash mismatch: ${name}`);
389
454
  added.set(name, data);
390
455
  }
391
- const removed = [...source.bytes.keys()].filter(name => !needed.has(name));
392
456
  if (!result && !removed.length && !extensionSave.removed.length) {
393
457
  if (revision === saveRevision) host.onSaved();
394
458
  notify();
@@ -403,8 +467,8 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
403
467
  manifest = encoder.encode(`${JSON.stringify(value, null, 2)}\n`);
404
468
  }
405
469
  const root = {directory: source.directory, files: source.files, prefix: ''};
406
- const assets = {directory: await source.directory.getDirectoryHandle('assets'), files: source.bytes, prefix: 'assets/'};
407
- const extensions = {directory: await source.directory.getDirectoryHandle('extensions'),
470
+ const assets = {directory: await source.directory.getDirectoryHandle('assets', {create: true}), files: source.bytes, prefix: 'assets/'};
471
+ const extensions = {directory: await source.directory.getDirectoryHandle('extensions', {create: true}),
408
472
  files: source.extensionBytes, prefix: 'extensions/'};
409
473
  const undo: (() => Promise<void>)[] = [];
410
474
  const write = async ({directory, files, prefix}: SaveDirectory, name: string, data: Uint8Array) => {
@@ -489,6 +553,7 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
489
553
  return {status: 'saved', sourceRemoved: extensionSave.sourceRemoved};
490
554
  } finally {
491
555
  busy = false;
556
+ notifyEdits();
492
557
  }
493
558
  },
494
559
  dispose
package/src/source.ts CHANGED
@@ -67,12 +67,14 @@ export type FolderSource = FolderFiles & {
67
67
  embedded: ExtensionManifest;
68
68
  };
69
69
 
70
- const getFile = async (dir: FileSystemDirectoryHandle, name: string) => (await dir.getFileHandle(name)).getFile();
70
+ const getFile = async (dir: FileSystemDirectoryHandle | null, name: string) =>
71
+ dir ? (await dir.getFileHandle(name)).getFile() : unsupported(`Missing folder for ${name}`);
71
72
  export const fileVersion = (file: File) => `${file.size}:${file.lastModified}`;
72
73
  const fileBytes = async (file: File) => new Uint8Array(await file.arrayBuffer());
73
- const readBytes = async (dir: FileSystemDirectoryHandle, name: string) => fileBytes(await getFile(dir, name));
74
- const readNames = async (dir: FileSystemDirectoryHandle) => {
74
+ const readBytes = async (dir: FileSystemDirectoryHandle | null, name: string) => fileBytes(await getFile(dir, name));
75
+ const readNames = async (dir: FileSystemDirectoryHandle | null) => {
75
76
  const names = new Set<string>();
77
+ if (!dir) return names;
76
78
  // Directory iteration is available alongside the picker, but absent from older DOM typings.
77
79
  for await (const entry of (dir as FileSystemDirectoryHandle & {values(): AsyncIterable<FileSystemHandle>}).values()) {
78
80
  if (entry.kind !== 'file') return unsupported('Nested entries are outside the supported source format');
@@ -80,6 +82,11 @@ const readNames = async (dir: FileSystemDirectoryHandle) => {
80
82
  }
81
83
  return names;
82
84
  };
85
+ // Git does not retain empty asset or extension directories.
86
+ const readDirectory = (dir: FileSystemDirectoryHandle, name: string) => dir.getDirectoryHandle(name).catch(error => {
87
+ if (error instanceof DOMException && error.name === 'NotFoundError') return null;
88
+ throw error;
89
+ });
83
90
  const sameNames = (actual: Set<string>, expected: Iterable<string>) => {
84
91
  const expectedNames = new Set(expected);
85
92
  return actual.size === expectedNames.size && [...actual].every(name => expectedNames.has(name));
@@ -267,7 +274,7 @@ export function planExtensionSave(source: FolderSource, project: Project) {
267
274
 
268
275
  export async function readFolder(directory: FileSystemDirectoryHandle, storage: Storage): Promise<FolderSource> {
269
276
  const versions = new Map<string, string>();
270
- const readEntry = async (dir: FileSystemDirectoryHandle, name: string, prefix = '') => {
277
+ const readEntry = async (dir: FileSystemDirectoryHandle | null, name: string, prefix = '') => {
271
278
  const file = await getFile(dir, name);
272
279
  versions.set(prefix + name, fileVersion(file));
273
280
  return [name, await fileBytes(file)] as const;
@@ -291,7 +298,7 @@ export async function readFolder(directory: FileSystemDirectoryHandle, storage:
291
298
  return unsupported('Asset references and archiveEntries do not match');
292
299
  }
293
300
  expected.delete('project.json');
294
- const [assets, extensions] = await Promise.all([directory.getDirectoryHandle('assets'), directory.getDirectoryHandle('extensions')]);
301
+ const [assets, extensions] = await Promise.all([readDirectory(directory, 'assets'), readDirectory(directory, 'extensions')]);
295
302
  const scripts = extensionNames(extensionManifest.extensions);
296
303
  if (!sameNames(await readNames(assets), expected) || !sameNames(await readNames(extensions), scripts)) {
297
304
  return unsupported('Unexpected or missing source files');
@@ -325,7 +332,7 @@ export async function readFolderUpdate(source: FolderSource, previous: FolderUpd
325
332
  const {directory, versions} = source;
326
333
  try {
327
334
  const [assets, extensions, project] = await Promise.all([
328
- directory.getDirectoryHandle('assets'), directory.getDirectoryHandle('extensions'), getFile(directory, projectFile)
335
+ readDirectory(directory, 'assets'), readDirectory(directory, 'extensions'), getFile(directory, projectFile)
329
336
  ]);
330
337
  const [assetNames, extensionNames] = await Promise.all([readNames(assets), readNames(extensions)]);
331
338
  if (!sameNames(assetNames, source.bytes.keys()) || !sameNames(extensionNames, source.extensionBytes.keys())) return 'structure';
@@ -356,8 +363,9 @@ export async function readFolderUpdate(source: FolderSource, previous: FolderUpd
356
363
 
357
364
  export async function assertFolderUnchanged(source: FolderSource) {
358
365
  try {
359
- const assets = await source.directory.getDirectoryHandle('assets');
360
- const extensions = await source.directory.getDirectoryHandle('extensions');
366
+ const [assets, extensions] = await Promise.all([
367
+ readDirectory(source.directory, 'assets'), readDirectory(source.directory, 'extensions')
368
+ ]);
361
369
  if (!sameNames(await readNames(assets), source.bytes.keys()) ||
362
370
  !sameNames(await readNames(extensions), source.extensionBytes.keys())) throw new FolderError('conflict');
363
371
  for (const [directory, files] of [[source.directory, source.files], [assets, source.bytes], [extensions, source.extensionBytes]] as const) {