@kubohiroya/turbowarp-plus-editor-project-folder 0.15.1 → 0.17.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 +11 -5
- package/README.md +9 -5
- package/dist/explorer.d.ts +3 -3
- package/dist/explorer.js +76 -20
- package/dist/folder-registry.d.ts +11 -4
- package/dist/index.d.ts +13 -3
- package/dist/index.js +81 -23
- package/dist/session.d.ts +17 -2
- package/dist/{shared-CUZGohh-.js → shared-CwQoV7xd.js} +1 -1
- package/dist/{shared-cwwWtggC.js → shared-h5VGx9Jp.js} +46 -6
- package/dist/source.d.ts +8 -0
- package/package.json +1 -1
- package/src/explorer.tsx +66 -13
- package/src/folder-registry.ts +14 -7
- package/src/index.ts +49 -15
- package/src/session.ts +27 -14
- package/src/source.ts +40 -0
package/src/index.ts
CHANGED
|
@@ -2,15 +2,16 @@ import {FolderError} from './source.js';
|
|
|
2
2
|
import {createFolderSession} from './session.js';
|
|
3
3
|
import {isProjectFolderEmpty} from './create-folder.js';
|
|
4
4
|
import {registerFolder} from './folder-registry.js';
|
|
5
|
+
import type {ProjectFolderLocation} from './folder-registry.js';
|
|
5
6
|
import {openBrowserProjects} from './browser-projects.js';
|
|
6
7
|
import type {BrowserProjects} from './browser-projects.js';
|
|
7
8
|
import {chooseBrowserProject} from './browser-project-dialog.js';
|
|
8
|
-
import type {FolderHost, FolderVM, PickerWindow} from './session.js';
|
|
9
|
+
import type {Chosen, FolderHost, FolderVM, PickerWindow} from './session.js';
|
|
9
10
|
|
|
10
11
|
export type {Comparison, ComparisonRequest, ComparisonSection, FolderHost, FolderScreenState, FolderVM, OpenResult} from './session.js';
|
|
11
12
|
export type {ReloadTarget} from './block-reload.js';
|
|
12
13
|
export {followProjectFolder} from './folder-registry.js';
|
|
13
|
-
export type {FollowedFolder} from './folder-registry.js';
|
|
14
|
+
export type {FollowedFolder, ProjectFolderLocation} from './folder-registry.js';
|
|
14
15
|
export type {DeserializeBlocks} from './script-reload.js';
|
|
15
16
|
export {createProjectFolder, projectFolderOverwriteWarning} from './create-folder.js';
|
|
16
17
|
export {openBrowserProjects} from './browser-projects.js';
|
|
@@ -21,7 +22,8 @@ export {zipDirectory} from './zip.js';
|
|
|
21
22
|
|
|
22
23
|
const messages = {
|
|
23
24
|
en: {
|
|
24
|
-
open: 'Open
|
|
25
|
+
open: 'Open Folder…', save: 'Save to Project Folder', openBrowser: 'Open Folder Saved in This Browser…',
|
|
26
|
+
deviceUnavailable: 'This browser cannot open folders on your device. Use Chrome or Edge, or open a folder saved in this browser.',
|
|
25
27
|
replace: 'Replace the open project and discard its unsaved changes?',
|
|
26
28
|
opened: 'Project folder opened.', saved: 'Project folder saved.', unchanged: 'No changes to save.',
|
|
27
29
|
sourceRemoved: (ids: string[]) => `Removed source metadata for replaced extensions: ${ids.join(', ')}. Use sb3-toolchain to fetch the managed sources again if you need to keep their provenance.`,
|
|
@@ -42,7 +44,8 @@ const messages = {
|
|
|
42
44
|
full: 'These changes need the whole project to be reloaded.'
|
|
43
45
|
},
|
|
44
46
|
ja: {
|
|
45
|
-
open: '
|
|
47
|
+
open: 'フォルダを開く…', save: 'プロジェクトフォルダに保存', openBrowser: 'ブラウザーに保存したフォルダを開く…',
|
|
48
|
+
deviceUnavailable: 'このブラウザーでは端末のフォルダを開けません。Chrome か Edge を使うか、ブラウザーに保存したフォルダを開いてください。',
|
|
46
49
|
replace: '未保存の変更を破棄して、別の作品を開きますか?',
|
|
47
50
|
opened: 'プロジェクトフォルダを開きました。', saved: 'プロジェクトフォルダに保存しました。', unchanged: '保存する変更はありません。',
|
|
48
51
|
sourceRemoved: (ids: string[]) => `差し替えた拡張機能(${ids.join('、')})の出どころ情報を削除しました。出どころを保つには、sb3-toolchain で拡張機能を取得し直してください。`,
|
|
@@ -73,8 +76,10 @@ interface MenuProps {
|
|
|
73
76
|
onRequestClose(): void;
|
|
74
77
|
}
|
|
75
78
|
type MenuEntry = {session: ReturnType<typeof createFolderSession>; open(locale: string): void; save(locale: string): void;
|
|
76
|
-
/** Opens a folder kept in this browser,
|
|
77
|
-
openBrowser?(locale: string): void
|
|
79
|
+
/** Opens a folder kept in this browser, wherever the browser's folders are available. */
|
|
80
|
+
openBrowser?(locale: string): void;
|
|
81
|
+
/** Whether the browser can pick folders on the device; without it, Open uses the browser's folders. */
|
|
82
|
+
deviceFolders: boolean};
|
|
78
83
|
const menus = new WeakMap<FolderVM, MenuEntry>();
|
|
79
84
|
|
|
80
85
|
type ObserverWindow = PickerWindow & {FileSystemObserver?: new (callback: () => void) => {
|
|
@@ -109,13 +114,24 @@ export function mountProjectFolder({vm, document, host, locale = 'en', autoReloa
|
|
|
109
114
|
const chooseBrowser = async (purpose: 'open' | 'create', title?: string) => {
|
|
110
115
|
const choice = await chooseBrowserProject({document, projects: browserProjects!, locale, purpose, title});
|
|
111
116
|
if (!choice) throw abort();
|
|
112
|
-
return choice
|
|
117
|
+
return choice;
|
|
118
|
+
};
|
|
119
|
+
// A folder kept in the browser was chosen as a whole, so its stored folder is the root even when the project is inside.
|
|
120
|
+
const chooseBrowserFolder = async (): Promise<Chosen> => {
|
|
121
|
+
const {project, directory} = await chooseBrowser('open');
|
|
122
|
+
return {directory, root: await browserProjects!.root(project.id).catch(() => null) ?? directory};
|
|
113
123
|
};
|
|
114
124
|
const pickDirectory = devicePicker ?
|
|
115
|
-
(options: {id: string; mode: 'readwrite'}) => devicePicker.call(view, options) :
|
|
116
|
-
|
|
117
|
-
const
|
|
118
|
-
|
|
125
|
+
async (options: {id: string; mode: 'readwrite'}): Promise<Chosen> => ({directory: await devicePicker.call(view, options)}) :
|
|
126
|
+
chooseBrowserFolder;
|
|
127
|
+
const locations: ProjectFolderLocation[] = [];
|
|
128
|
+
if (devicePicker) locations.push('device');
|
|
129
|
+
if (browserProjects) locations.push('browser');
|
|
130
|
+
const pickNewDirectory = async (options: {id: string; mode: 'readwrite'}, title?: string,
|
|
131
|
+
location: ProjectFolderLocation = devicePicker ? 'device' : 'browser') => {
|
|
132
|
+
if (!locations.includes(location)) throw new FolderError('unsupported');
|
|
133
|
+
return location === 'device' ? devicePicker!.call(view, options) : (await chooseBrowser('create', title)).directory;
|
|
134
|
+
};
|
|
119
135
|
/** Runs `run` with the browser folder of `directory` locked against other tabs, and marks it as updated. */
|
|
120
136
|
const withBrowserProject = async <T>(directory: FileSystemDirectoryHandle | null, run: () => Promise<T>) => {
|
|
121
137
|
const project = directory && browserProjects ? await browserProjects.find(directory).catch(() => null) : null;
|
|
@@ -271,6 +287,7 @@ export function mountProjectFolder({vm, document, host, locale = 'en', autoReloa
|
|
|
271
287
|
};
|
|
272
288
|
}
|
|
273
289
|
const menu: MenuEntry = {
|
|
290
|
+
deviceFolders: typeof devicePicker === 'function',
|
|
274
291
|
session,
|
|
275
292
|
open(locale) {
|
|
276
293
|
const message = messageFor(locale);
|
|
@@ -278,9 +295,9 @@ export function mountProjectFolder({vm, document, host, locale = 'en', autoReloa
|
|
|
278
295
|
.then(result => {if (result === 'opened') report(message.opened);}, error => fail(locale, error)).finally(renderReload);
|
|
279
296
|
renderReload();
|
|
280
297
|
},
|
|
281
|
-
openBrowser:
|
|
298
|
+
openBrowser: browserProjects ? locale => {
|
|
282
299
|
const message = messageFor(locale);
|
|
283
|
-
session.open(
|
|
300
|
+
session.open(chooseBrowserFolder, () => view.confirm(message.replace))
|
|
284
301
|
.then(result => {if (result === 'opened') report(message.opened);}, error => fail(locale, error)).finally(renderReload);
|
|
285
302
|
renderReload();
|
|
286
303
|
} : undefined,
|
|
@@ -303,6 +320,8 @@ export function mountProjectFolder({vm, document, host, locale = 'en', autoReloa
|
|
|
303
320
|
menus.set(vm, menu);
|
|
304
321
|
const unregister = registerFolder(vm, {
|
|
305
322
|
get directory() {return session.directory;},
|
|
323
|
+
get root() {return session.root;},
|
|
324
|
+
locations,
|
|
306
325
|
subscribe: listener => session.subscribe(listener),
|
|
307
326
|
subscribeEdits: listener => session.subscribeEdits(listener),
|
|
308
327
|
unsavedPaths: () => session.unsavedPaths(),
|
|
@@ -322,19 +341,21 @@ export function mountProjectFolder({vm, document, host, locale = 'en', autoReloa
|
|
|
322
341
|
* Creates a project folder from a snapshot. `title` names a folder made in the browser, where the user names a
|
|
323
342
|
* new folder instead of picking one on the device.
|
|
324
343
|
*/
|
|
325
|
-
createFromSnapshot({prepareFiles, collectEdits, directory, current = () => true, title}: {
|
|
344
|
+
createFromSnapshot({prepareFiles, collectEdits, directory, current = () => true, title, location}: {
|
|
326
345
|
prepareFiles: () => Promise<ReadonlyMap<string, Uint8Array>>;
|
|
327
346
|
collectEdits?: () => Promise<void>;
|
|
328
347
|
directory?: FileSystemDirectoryHandle;
|
|
329
348
|
current?: () => boolean;
|
|
330
349
|
title?: string;
|
|
350
|
+
/** Explicit destination; omitted uses the device picker when available. */
|
|
351
|
+
location?: ProjectFolderLocation;
|
|
331
352
|
}) {
|
|
332
353
|
const message = locale.startsWith('ja') ?
|
|
333
354
|
'指定されたフォルダは空ではありません。フォルダに保存されている内容が上書きされる場合があります。よろしいですか?' :
|
|
334
355
|
'The selected folder is not empty. Contents in the folder may be overwritten. Continue?';
|
|
335
356
|
return session.createFromSnapshot(async () => {
|
|
336
357
|
try {
|
|
337
|
-
const selected = directory ?? await pickNewDirectory({id: 'turbowarp-plus-project-folder', mode: 'readwrite'}, title);
|
|
358
|
+
const selected = directory ?? await pickNewDirectory({id: 'turbowarp-plus-project-folder', mode: 'readwrite'}, title, location);
|
|
338
359
|
if (!current()) return null;
|
|
339
360
|
const overwrite = !await isProjectFolderEmpty(selected);
|
|
340
361
|
if (!current() || (overwrite && !view.confirm(message))) return null;
|
|
@@ -351,6 +372,11 @@ export function mountProjectFolder({vm, document, host, locale = 'en', autoReloa
|
|
|
351
372
|
* detached. A host can tell projects apart by it, for example to keep the layout of each one.
|
|
352
373
|
*/
|
|
353
374
|
get directory() {return session.directory;},
|
|
375
|
+
/**
|
|
376
|
+
* The folder the user chose for the loaded project, or `null` like `directory`. It is `directory` itself, or
|
|
377
|
+
* the repository whose `project` folder holds the project, or the stored folder of a folder kept in the browser.
|
|
378
|
+
*/
|
|
379
|
+
get root() {return session.root;},
|
|
354
380
|
dispose() {
|
|
355
381
|
menus.delete(vm);
|
|
356
382
|
unregister();
|
|
@@ -368,6 +394,8 @@ export function projectFolderActions(vm: FolderVM, locale = 'en') {
|
|
|
368
394
|
return {
|
|
369
395
|
open: () => entry.open(locale),
|
|
370
396
|
openBrowser: entry.openBrowser ? () => entry.openBrowser!(locale) : undefined,
|
|
397
|
+
/** Whether Open can pick a folder on the device. Safari and Firefox cannot, so hosts show Open as unavailable. */
|
|
398
|
+
deviceFolders: entry.deviceFolders,
|
|
371
399
|
save: entry.session.canSave ? () => entry.save(locale) : undefined,
|
|
372
400
|
detach: () => entry.session.detach()
|
|
373
401
|
};
|
|
@@ -380,6 +408,12 @@ export function renderProjectFolderMenu(createElement: MenuElement, {
|
|
|
380
408
|
if (!entry) return null;
|
|
381
409
|
const labels = locale.startsWith('ja') ? messages.ja : messages.en;
|
|
382
410
|
const item = (action: 'open' | 'openBrowser' | 'save') => {
|
|
411
|
+
// Without the device's folder picker, Open is shown but unavailable; the browser's folders have their own item.
|
|
412
|
+
if (action === 'open' && !entry.deviceFolders) {
|
|
413
|
+
return createElement(MenuItem, {command: `project-folder-${action}`},
|
|
414
|
+
createElement('span', {role: 'button', tabIndex: -1, 'aria-disabled': true, title: labels.deviceUnavailable,
|
|
415
|
+
style: {opacity: 0.5, cursor: 'default'}}, labels[action]));
|
|
416
|
+
}
|
|
383
417
|
const run = () => {onRequestClose(); entry[action]!(locale);};
|
|
384
418
|
return createElement(MenuItem, {command: `project-folder-${action}`, onClick: run},
|
|
385
419
|
createElement('span', {role: 'button', tabIndex: 0, onKeyDown(event: KeyboardEvent) {
|
package/src/session.ts
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
1
|
import {assetKey, assetTypeFor, assertFolderUnchanged, collapsePalette, encodePalette, expandPalette, extensionsFile, fileVersion,
|
|
2
|
-
equal, FolderError, manifestFile, paletteFile, parseProject, planExtensionSave, projectAssets, projectChanges, projectFile,
|
|
2
|
+
equal, FolderError, manifestFile, paletteFile, parseProject, planExtensionSave, projectAssets, projectChanges, projectFile, readProjectFolder,
|
|
3
3
|
readFolderUpdate, sameBytes, unsupported} from './source.js';
|
|
4
4
|
import type {Asset, AssetKind, FolderSource, FolderUpdate, JsonObject, Project, Storage} from './source.js';
|
|
5
5
|
import {applyBlockReload, planBlockReload} from './block-reload.js';
|
|
@@ -131,7 +131,9 @@ type Edits = {kind: 'values'; changes: ReturnType<typeof planBlockReload>} |
|
|
|
131
131
|
{kind: 'scripts'; changes: ReturnType<typeof planScriptReload>};
|
|
132
132
|
type PendingUpdate = {update: FolderUpdate; edits: Edits | null; stable: boolean};
|
|
133
133
|
type Pending = PendingUpdate | 'structure' | 'waiting';
|
|
134
|
-
|
|
134
|
+
/** The folder to open, and the folder the user chose for it, which defaults to `directory`. */
|
|
135
|
+
export type Chosen = {directory: FileSystemDirectoryHandle; root?: FileSystemDirectoryHandle};
|
|
136
|
+
type Session = {source: FolderSource; root: FileSystemDirectoryHandle; baseline: Project; ids: string[] | undefined; stage: object; pending: Pending | null};
|
|
135
137
|
/**
|
|
136
138
|
* `ready`: the change can be applied in place: values and positions, or with `deserializeBlocks`, whole scripts. `full`: the change needs the whole project reloaded.
|
|
137
139
|
* `waiting`: an external write looks incomplete and is checked again. `dirty`, `running` and `busy` hold the change.
|
|
@@ -274,20 +276,20 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
|
|
|
274
276
|
unregisterTree?.();
|
|
275
277
|
};
|
|
276
278
|
const openFrom = async (
|
|
277
|
-
getDirectory: () => Promise<
|
|
279
|
+
getDirectory: () => Promise<Chosen | null>,
|
|
278
280
|
confirmReplace: () => boolean,
|
|
279
281
|
prepare: (directory: FileSystemDirectoryHandle) => Promise<FolderSource | null> =
|
|
280
|
-
directory =>
|
|
282
|
+
directory => readProjectFolder(directory, vm.runtime.storage),
|
|
281
283
|
stillCurrent = () => true
|
|
282
284
|
): Promise<OpenResult> => {
|
|
283
285
|
if (disposed || busy) return 'cancelled';
|
|
284
286
|
busy = true;
|
|
285
287
|
const priorStage = vm.runtime.getTargetForStage();
|
|
286
288
|
try {
|
|
287
|
-
const
|
|
288
|
-
if (!
|
|
289
|
+
const chosen = await getDirectory();
|
|
290
|
+
if (!chosen || disposed) return 'cancelled';
|
|
289
291
|
const storage = vm.runtime.storage;
|
|
290
|
-
const source = await prepare(directory);
|
|
292
|
+
const source = await prepare(chosen.directory);
|
|
291
293
|
if (!source || disposed || !stillCurrent() || vm.runtime.getTargetForStage() !== priorStage) return 'cancelled';
|
|
292
294
|
if (host.isProjectDirty() && !confirmReplace()) return 'cancelled';
|
|
293
295
|
host.beforeLoad();
|
|
@@ -296,6 +298,8 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
|
|
|
296
298
|
const assets = source.storageAssets;
|
|
297
299
|
reader.assets = assets;
|
|
298
300
|
let stage: object | null;
|
|
301
|
+
// The project may be the `project` folder inside the chosen one.
|
|
302
|
+
const directory = source.directory;
|
|
299
303
|
pendingTree = undefined;
|
|
300
304
|
expectingTree = true;
|
|
301
305
|
try {
|
|
@@ -307,9 +311,9 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
|
|
|
307
311
|
if (reader.assets === assets) reader.assets = null;
|
|
308
312
|
}
|
|
309
313
|
if (disposed || !stage || vm.runtime.getTargetForStage() !== stage) return 'cancelled';
|
|
310
|
-
host.onOpened(directory.name);
|
|
314
|
+
host.onOpened(chosen.directory.name);
|
|
311
315
|
const baseline = snapshot();
|
|
312
|
-
setCurrent({source, stage, baseline, ids: identify(baseline), pending: null});
|
|
316
|
+
setCurrent({source, root: chosen.root ?? chosen.directory, stage, baseline, ids: identify(baseline), pending: null});
|
|
313
317
|
// The tree may come with the load or right after it; once the folder is current, it is written there.
|
|
314
318
|
expectingTree = false;
|
|
315
319
|
if (pendingTree) writeExplorerState(directory, pendingTree, true);
|
|
@@ -432,6 +436,8 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
|
|
|
432
436
|
return typeof pending === 'object' && pending !== null ? pending.update.version : null;
|
|
433
437
|
},
|
|
434
438
|
get directory() {return current?.source.directory ?? null;},
|
|
439
|
+
/** The folder the user chose: `directory` itself, or the repository whose `project` folder it is. */
|
|
440
|
+
get root() {return current?.root ?? null;},
|
|
435
441
|
async mutate(directory: FileSystemDirectoryHandle, operation: (guard: () => void) => Promise<void>) {
|
|
436
442
|
const session = current;
|
|
437
443
|
if (!session || busy || session.source.directory !== directory) throw new FolderError('conflict');
|
|
@@ -528,9 +534,11 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
|
|
|
528
534
|
if (!session || !session.pending || session.pending === 'waiting' || host.blockReload?.isRunning()) {
|
|
529
535
|
return Promise.resolve('cancelled');
|
|
530
536
|
}
|
|
531
|
-
return openFrom(() => Promise.resolve(current === session ? session.source.directory : null),
|
|
537
|
+
return openFrom(() => Promise.resolve(current === session ? {directory: session.source.directory, root: session.root} : null),
|
|
538
|
+
confirmReplace);
|
|
532
539
|
},
|
|
533
|
-
|
|
540
|
+
/** `pick` gives the folder to open and, when it differs, the folder the user chose as `root`. */
|
|
541
|
+
open(pick: (options: {id: string; mode: 'readwrite'}) => Promise<Chosen>, confirmReplace: () => boolean): Promise<OpenResult> {
|
|
534
542
|
return openFrom(async () => {
|
|
535
543
|
try {
|
|
536
544
|
return await pick({id: 'turbowarp-plus-project-folder', mode: 'readwrite'});
|
|
@@ -540,8 +548,13 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
|
|
|
540
548
|
}
|
|
541
549
|
}, confirmReplace);
|
|
542
550
|
},
|
|
543
|
-
|
|
544
|
-
|
|
551
|
+
/**
|
|
552
|
+
* Opens `directory`, or its `project` folder when it has no project of its own. `root` is the folder the user
|
|
553
|
+
* chose, for a host that located the project itself; it defaults to `directory`.
|
|
554
|
+
*/
|
|
555
|
+
openDirectory(directory: FileSystemDirectoryHandle, confirmReplace: () => boolean,
|
|
556
|
+
root?: FileSystemDirectoryHandle): Promise<OpenResult> {
|
|
557
|
+
return openFrom(() => Promise.resolve({directory, root}), confirmReplace);
|
|
545
558
|
},
|
|
546
559
|
createFromSnapshot(selectDestination: () => Promise<{directory: FileSystemDirectoryHandle; overwrite: boolean} | null>,
|
|
547
560
|
prepareFiles: () => Promise<ReadonlyMap<string, Uint8Array>>, isCurrent: () => boolean): Promise<OpenResult> {
|
|
@@ -553,7 +566,7 @@ export function createFolderSession(vm: FolderVM, host: FolderHost) {
|
|
|
553
566
|
return openFrom(async () => {
|
|
554
567
|
const destination = await selectDestination();
|
|
555
568
|
overwrite = destination?.overwrite ?? false;
|
|
556
|
-
return destination
|
|
569
|
+
return destination ? {directory: destination.directory} : null;
|
|
557
570
|
}, currentProject, async directory => {
|
|
558
571
|
if (!currentProject()) return null;
|
|
559
572
|
savedRevision = revision;
|
package/src/source.ts
CHANGED
|
@@ -374,6 +374,46 @@ export async function readFolder(directory: FileSystemDirectoryHandle, storage:
|
|
|
374
374
|
palette: paletteDocument};
|
|
375
375
|
}
|
|
376
376
|
|
|
377
|
+
/** The project folder inside a repository, as Project Starter makes it. */
|
|
378
|
+
export const projectSubfolder = 'project';
|
|
379
|
+
|
|
380
|
+
const missingEntry = (error: unknown) => error instanceof DOMException && ['NotFoundError', 'TypeMismatchError'].includes(error.name);
|
|
381
|
+
/** Whether `directory` has an entry called `name`, a file or a folder. */
|
|
382
|
+
async function hasEntry(directory: FileSystemDirectoryHandle, name: string) {
|
|
383
|
+
for (const get of [() => directory.getFileHandle(name), () => directory.getDirectoryHandle(name)]) {
|
|
384
|
+
try {
|
|
385
|
+
await get();
|
|
386
|
+
return true;
|
|
387
|
+
} catch (error) {
|
|
388
|
+
if (!missingEntry(error)) throw error;
|
|
389
|
+
}
|
|
390
|
+
}
|
|
391
|
+
return false;
|
|
392
|
+
}
|
|
393
|
+
|
|
394
|
+
/**
|
|
395
|
+
* Reads the project in `directory`, or, when the folder has no project of its own, in its `project` folder, as in a
|
|
396
|
+
* repository whose project sits in `project/`. That folder must not be a repository itself. The error is the one
|
|
397
|
+
* for `directory` when neither holds a project.
|
|
398
|
+
*/
|
|
399
|
+
export async function readProjectFolder(directory: FileSystemDirectoryHandle, storage: Storage): Promise<FolderSource> {
|
|
400
|
+
try {
|
|
401
|
+
return await readFolder(directory, storage);
|
|
402
|
+
} catch (error) {
|
|
403
|
+
const child = await (async () => {
|
|
404
|
+
if (await hasEntry(directory, projectFile) || await hasEntry(directory, manifestFile)) return null;
|
|
405
|
+
const found = await directory.getDirectoryHandle(projectSubfolder);
|
|
406
|
+
return await hasEntry(found, '.git') ? null : found;
|
|
407
|
+
})().catch(() => null);
|
|
408
|
+
if (!child) throw error;
|
|
409
|
+
try {
|
|
410
|
+
return await readFolder(child, storage);
|
|
411
|
+
} catch {
|
|
412
|
+
throw error;
|
|
413
|
+
}
|
|
414
|
+
}
|
|
415
|
+
}
|
|
416
|
+
|
|
377
417
|
export const sameBytes = (a: Uint8Array, b: Uint8Array) => a.length === b.length && a.every((value, index) => value === b[index]);
|
|
378
418
|
|
|
379
419
|
export type FolderUpdate = {version: string; bytes: Uint8Array; project: Project};
|